# -*- coding: utf-8 -*-
 ##############################################
 ##                                            ##
 ##           View for Ventas package           ##
 ##                                             ##
 ##                                             ##
 ##              from Basiq Series              ##
 ##           by Críptidos Digitales            ##
 ##                 GPL (c)2008                 ##
  ##                                            ##
    ##############################################

"""
"""

import sys
from decimal import Decimal
from PyQt4 import QtCore, QtGui
import datetime

from cdWidgets import cdFrame, cdNumberEdit

import frame_ui
import administradorVentas_ui as administrador_ui
import capturaVenta_ui as captura_ui
import detallesVenta_ui as detalles_ui
import pagos_ui

from personas import selector as selectorCliente


import model

import utilities

VENTA_ID, FOLIO, FECHA, ENTIDAD, SUBTOTAL, DESCUENTOS, IMPUESTOS, TOTAL, STATUS = range(9)

CODIGO, NOMBRE, LINEA, CANTIDAD, PRECIO, IMPORTE = range(6)



class st: pass

st.Ok = 0
st.NotEmpty = 1
st.NotValid = 2
st.Modified = 4
st.OutOfRange = 8

st.TaxIncluded  = 1
st.TaxOmitted   = 0



class Forma(cdFrame.CDFrame):

    @property
    def mode(self):
        return self.__mode

    def __init__(self, *args, **kwds):
        m = "ventas.igu.Forma.__init__()"

        if kwds.has_key('mode'):
            self.__mode = kwds.pop('mode')
        else:
            self.__mode = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None


        cdFrame.CDFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        ## Detalles
        self.detalles = Detalles(self, owner=self)
        self.detalles.hide()

        ## Captura
        self.captura = Captura(self, owner=self)
        self.connect(self.captura, QtCore.SIGNAL('capturaClosed()'), self.capturaClosed)

        ## Administrador
        self.administrador = Administrador(self, owner=self)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)
        ## InnerSplitter
        self.ui.innerSplitter = Splitter(QtCore.Qt.Vertical, self.ui.outerSplitter)
        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL("handlePressed"), self.innerHandlePressed)
        self.ui.innerSplitter.setSizes([1, 1])

        ## OuterSplitter
        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)
        self.ui.outerSplitter.setSizes([1, 1])
        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)

        if self.mode == 'consulta':
            self.captura.ui.boCancelar.show()
            self.captura.hide()
            self.administrador.ui.toAgregar.hide()
            self.administrador.menuTablaConsulta.removeAction(self.administrador.aAgregar)

        elif self.mode == 'captura':
            self.administrador.hide()
            self.administrador.aEliminar.setEnabled(False)
            self.captura.ui.boCancelar.hide()
            self.captura.agrega()

        self.impresor = QtGui.QPrinter()


    def capturaClosed(self):
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()


    def imprime(self, document=None): # print "ventas.igu.Forma.imprime()"

        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:

            painter = QtGui.QPainter(self.impresor)

            #~ procesoServicioZero = [x for x in documento.operacion.procesos if x.tipo==u'servicio']
            #~ if procesoServicioZero:
                #~ servicio = [x.documento.servicio for x in procesoServicio[0].operaciones if x.tipo==u'recepción'][0]

            ## LISTA FILTRADA
            if documento is None:
                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenHorizontal, margenVertical = [10, 10]
                margenX, margenY = [25, 75]
                pageNo = 1
                contenido = []

                ## Header
                # Nombre de documento
                x,y = [ 20, 20]; contenido.append([margenX+x, margenY+y, u"Listado de Ventas"])
                # Fecha
                x,y = [528, 20]; contenido.append([margenX+x, margenY+y, u"%s" % datetime.datetime.today().strftime('%d de %B de %Y')])
                # Labels
                x,y = [ 25, 90]; contenido.append([margenX+x, margenY+y, u"Documento"])
                x,y = [140, 90]; contenido.append([margenX+x, margenY+y, u"Fecha"])
                x,y = [245, 90]; contenido.append([margenX+x, margenY+y, u"Monto"])
                x,y = [330, 90]; contenido.append([margenX+x, margenY+y, u"Status"])
                x,y = [435, 90]; contenido.append([margenX+x, margenY+y, u"Cliente"])

                x,y = [  0,120]
                offset = 0

                tabla = self.administrador.ui.tablaConsulta
                for rowIndex in range(tabla.rowCount()):
                    proceso = model.getFullProcess(id=tabla.item(rowIndex, 0).data(QtCore.Qt.UserRole).toInt()[0])

                    documentoX = ([xx for xx in proceso['operations'] if xx['tipo']==u'salida'][0])['documents'][0]

                    contenido.append([margenX+x+ 20, margenY+y+offset, "%s %s" % (documentoX['tipo'].nombre.capitalize(), documentoX['folio'])])
                    contenido.append([margenX+x+135, margenY+y+offset, documentoX['fecha'].strftime("%d-%b-%Y")])
                    contenido.append([margenX+x+250, margenY+y+offset, "%s" % documentoX['total']])
                    contenido.append([margenX+x+330, margenY+y+offset, documentoX['status']])
                    contenido.append([margenX+x+420, margenY+y+offset, "%s %s" % (documentoX['rol']['nombre'], documentoX['rol']['nombre2'])])
                    offset += 25

                for item in contenido:
                    painter.drawText(QtCore.QPoint(item[0], item[1]), item[2])

            ## Documento 1 (Factura)
            elif document['tipo'].nombre == u'factura':

                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenX, margenY = [35, 85]

                pageNo = 1

                format = file("propio/factura.txt").read()
                formatList = format.replace("\n\n", "\n").split("\n")
                format = [(x.split(",")) for x in formatList]

                format = dict([(x[0], [int(y) for y in x[1:] if y]) for x in format if x[0][0]!="#"])

                # Folio
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0], margenY+format['folio'][1]), document['folio'])

                # Fecha
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0], margenY+format['fecha'][1]), document['fecha'].strftime('%d de %B de %Y'))

                # Nombre
                painter.drawText(QtCore.QPoint(margenX+format['nombre'][0], margenY+format['nombre'][1]), u"%s %s" % (document['rol']['nombre'], document['rol']['nombre2']))

                # Calle y colonia
                painter.drawText(QtCore.QPoint(margenX+format['direccion'][0], margenY+format['direccion'][1]), u"%s %s" % (document['rol']['addresses'][0]['calle'], document['rol']['addresses'][0]['areanominal']))

                # CP y Lugar
                painter.drawText(QtCore.QPoint(margenX+format['lugar'][0], margenY+format['lugar'][1]), u"CP %s   %s" % (document['rol']['addresses'][0]['areapostal'], document['rol']['addresses'][0]['lugar'].nombre))

                # RFC
                painter.drawText(QtCore.QPoint(margenX+format['rfc'][0], margenY+format['rfc'][1]), document['rol']['rfc'])

                if procesoServicioZero:
                    # Código
                    painter.drawText(QtCore.QPoint(margenX+format['economico'][0], margenY+format['economico'][1]), servicio.equipo.codigo)

                    # Marca
                    painter.drawText(QtCore.QPoint(margenX+format['marca'][0], margenY+format['marca'][1]), "%s %s" % (servicio.equipo.marca.nombre, servicio.equipo.linea.nombre))

                    painter.drawText(QtCore.QPoint(margenX+formet['serie'][0], margenY+format['serie'][1]), "Serie %s" % servicio.equipo.serie)

                    # Modelo
                    painter.drawText(QtCore.QPoint(margenX+format['modelo'][0], margenY+format['modelo'][1]), servicio.equipo.modelo.nombre)

                    # Registro
                    painter.drawText(QtCore.QPoint(margenX+format['placa'][0], margenY+format['placa'][1]), servicio.equipo.registro)

                    # Nivel 2
                    painter.drawText(QtCore.QPoint(margenX+format['odometro'][0], margenY+format['odometro'][1]), servicio.nivel2)

                x, y = format['partidas']
                offset = 0

                for partida in document['partidas']:
                    acepcion = model.getFullAception(producto_id=partida['producto_id'], rol_id=app.holder['id'])
                    painter.drawText(QtCore.QPoint(margenX+format['cantidad'][0], margenY+y+offset), "%s" % partida['cantidad'])
                    painter.drawText(QtCore.QPoint(margenX+format['codigo'][0], margenY+y+offset), aception['codigo'])
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0], margenY+y+offset), aception['nombre'])
                    painter.drawText(QtCore.QPoint(margenX+format['linea'][0], margenY+y+offset), aception['product']['lines'][0]['nombre'])
                    painter.drawText(QtCore.QPoint(margenX+format['importe'][0], margenY+y+offset), "%8.2f" % (partida['cantidad'] * partida['precio']))
                    offset += 20

                # Cantidad con letra
                painter.drawText(QtCore.QPoint(margenX+format['cantidadconletra'][0], margenY+format['cantidadconletra'][1]), "(%s M.N.)" % utilities.moneyToText(document['total'].quantize(session.moneyDecimals)))

                # Subtotal
                painter.drawText(QtCore.QPoint(margenX+format['subtotal'][0], margenY+format['subtotal'][1]), "%8.2f" % document['subtotal'])
                painter.drawText(QtCore.QPoint(margenX+format['impuesto'][0], margenY+format['impuesto'][1]), "%8.2f" % document['impuesto'])
                painter.drawText(QtCore.QPoint(margenX+format['total'][0], margenY+format['total'][1]), "%8.2f" % document['total'])

                # Pagaré
                if len(format['pagare.total']) == 4:
                    font.setPointSize(10)
                    painter.setFont(font)
                painter.drawText(QtCore.QPoint(margenX+format['pagare.total'][0], margenY+format['pagare.total'][1]), "%8.2f" % document['total'])
                painter.drawText(QtCore.QPoint(margenX+format['pagare.total'][0], margenY+format['pagare.total'][1]), "(%s M.N.)" % utilities.moneyToText(document['total'].quantize(session.moneyDecimals)))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.fecha'][0], margenY+format['pagare.fecha'][1]), document['fecha'].strftime('%d de %B de %Y'))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.interes'][0], margenY+format['pagare.interes'][1]), "10")
                painter.drawText(QtCore.QPoint(margenX+format['pagare.nombre'][0], margenY+format['pagare.nombre'][1]), u"%s %s" % (document['rol']['nombre'], document['rol']['nombre2']))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.direccion'][0], margenY+format['pagare.direccion'][1]), u"%s %s %s %s" % (document['rol']['addresses'][0]['calle'], document['rol']['addresses'][0]['areanominal'], document['rol']['addresses'][0]['areapostal'], document['rol']['addresses'][0]['lugar'].nombre))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.fecha'][0], margenY+format['pagare.fecha'][1]), document['fecha'].strftime('%d de %B de %Y'))


            ## DOCUMENTO 2 (REMISIÓN)
            elif document['tipo']['nombre'] == u'remisión':

                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenX, margenY = [35, 35]
                pageNo = 1

                formatList = file("propio/remision.txt").read()
                formatList = formatList.replace("\n\n", "\n").replace("\n\n", "\n").replace("\n\n", "\n").split("\n")
                format = {}
                for item in formatList:
                    if item and item != ' ':
                        items = item.split(" , ")
                        if items[0][0] != "#":
                            items[1] = int(items[1])
                            items[2] = int(items[2])
                            format[items[0]] = items[1:]

                # Logo
                painter.drawPixmap(QtCore.QPoint(margenX, margenY), QtGui.QPixmap("propio/logo.jpg"))

                # Folio
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0]+30, margenY+format['folio'][1]-25), u"REMISIÓN")
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0]+40, margenY+format['folio'][1]), document['folio'])

                # Fecha
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0]+40, margenY+format['fecha'][1]-25), u"FECHA")
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0], margenY+format['fecha'][1]), document['fecha'].strftime('%d de %B de %Y'))

                # Cliente Nombre
                painter.drawText(QtCore.QRectF(margenX+format['cliente.nombre'][0]-125, margenY+format['cliente.nombre'][1], 100, 30), u"Cliente", QtGui.QTextOption(QtCore.Qt.AlignRight))

                painter.drawText(QtCore.QRectF(margenX+format['cliente.nombre'][0],  margenY+format['cliente.nombre'][1], margenX+format['cliente.nombre'][0]+400, margenY+format['cliente.nombre'][1]), u"%s %s" % (document['rol']['nombre'], document['rol']['nombre2']))

                if procesoServicioZero:
                    # Vehiculo
                    painter.drawText(QtCore.QRectF(margenX+format['vehiculo.descripcion'][0]-100, margenY+format['vehiculo.descripcion'][1], margenX+format['vehiculo.descripcion'][0], margenY+format['vehiculo.descripcion'][1]-10, margenY+format['vehiculo.descripcion'][1]+20), u"Vehículo", QtGui.QTextOption(QtCore.Qt.AlignRight))

                    painter.drawText(QtCore.QPoint(margenX+format['vehiculo.descripcion'][0], margenY+format['vehiculo.descripcion'][1]), "%s %s %s %s %s" % (servicio.equipo.codigo, servicio.equipo.marca.nombre, servicio.equipo.linea.nombre, servicio.equipo.modelo.nombre, servicio.equipo.registro))

                # Partidas
                x, y = format['partidas']
                offset = 0

                painter.drawText(QtCore.QPoint(margenX+10, margenY+y-35), u"CANTIDAD")
                painter.drawText(QtCore.QPoint(margenX+190, margenY+y-35), u"CONCEPTO")
                painter.drawText(QtCore.QPoint(margenX+610, margenY+y-35), u"IMPORTE")

                for partida in documento.partidas:
                    acepcion = model.getAception(producto_id=partida['producto_id'], rol_id=app.holder['id'])
                    painter.drawText(QtCore.QPoint(margenX+format['cantidad'][0], margenY+y+offset), "%s" % partida['cantidad'])
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0], margenY+y+offset), aception['codigo'])
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0]+90, margenY+y+offset), aception['nombre'])
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0]+290, margenY+y+offset), aception['producto']['clasificacion']['nombre'])
                    painter.drawText(QtCore.QRectF(margenX+format['importe'][0], margenY+y+offset-10, 115, 20), "%8.2f" % (partida['cantidad'] * partida['precio']), QtGui.QTextOption(QtCore.Qt.AlignRight))
                    offset += 20

                # Cantidad con letras
                painter.drawText(QtCore.QPoint(margenX+format['cantidadconletra'][0], margenY+format['cantidadconletra'][1]), "(%s M.N.)" % utilities.moneyToText(document['total'].quantize(session.moneyDecimals)))

                # Total
                painter.drawText(QtCore.QRectF(margenX+format['total'][0]-100, margenY+format['total'][1]+5, 100, 20), u"Total", QtGui.QTextOption(QtCore.Qt.AlignRight))

                painter.drawText(QtCore.QRectF(margenX+format['total'][0], margenY+format['total'][1]+5, 115, 20), "%8.2f" % document['subtotal'], QtGui.QTextOption(QtCore.Qt.AlignRight))

                # PAGARÉ
                painter.drawText(QtCore.QRectF(margenX+format['pagare.texto'][0]+10, margenY+format['pagare.texto'][1]+10, margenX+format['pagare.texto'][0]+660, margenY+format['pagare.texto'][1]+180), (format['pagare.texto'][2] % (u"%8.2f" % document['subtotal'], document['fecha'].strftime('%d de %B de %Y'), unicode("%s %s", "latin1") % (document['rol']['nombre'], document['rol']['nombre2']), u"", document['fecha'].strftime('%d de %B de %Y'))).replace(u'[LF]', u'\n'))


                pen = painter.pen()
                pen.setWidth(2)
                painter.setPen(pen)

                # MARCO FOLIO
                painter.drawRect(QtCore.QRect(margenX+format['folio'][0]-20, margenY+format['folio'][1]-40, 175, 20))
                painter.drawRect(QtCore.QRect(margenX+format['folio'][0]-20, margenY+format['folio'][1]-20, 175, 30))

                # Marco Fecha
                painter.drawRect(QtCore.QRect(margenX+format['fecha'][0]-20, margenY+format['fecha'][1]-40, 175, 20))
                painter.drawRect(QtCore.QRect(margenX+format['fecha'][0]-20, margenY+format['fecha'][1]-20, 175, 30))

                # Marco Labels
                painter.drawRect(QtCore.QRect(margenX, margenY+y-50, 700, 25))  # Labels

                # Marco Total
                painter.drawRect(QtCore.QRect(margenX+format['total'][0]+25, margenY+format['total'][1], 100, 30))

                # Marco pagaré
                painter.drawRect(QtCore.QRect(margenX+format['pagare.texto'][0], margenY+format['pagare.texto'][1], 700, 200))

                for marco in [format[x] for x in format.keys() if 'marco' in x]:
                    painter.drawRect(margenX+marco[0], margenY+marco[1], int(marco[2]), int(marco[3]))


    def innerHandlePressed(self):
        self.toggleDetalles()

    def outerHandlePressed(self):
        if self.mode == 'consulta':
            if self.ui.outerSplitter.sizes()[0] == 0:
                self.setInnerStatus('visible')
            else:
                self.setInnerStatus('hidden')

    @property
    def owner(self):
        return self.__owner


    def setInnerStatus(self, value):
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"
        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()
        elif value == 'disabled':
            print 'disables'


    def toggleDetalles(self, *args):
        if self.detalles.isVisible():
            self.detalles.hide()
        else:
            if self.administrador.ui.tablaConsulta.currentRow() != -1:
                id = self.administrador.ui.tablaConsulta.item(self.administrador.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                if id != -1:
                    self.detalles.show()
                    process = model.getFullProcess(proceso_id=id)
                    self.detalles.setData(process)



class Administrador(cdFrame.CDFrame):

    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## FILTROS
        self.ui.laFiltroCliente.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        ## Filtros - Nombre de cliente
        completer = QtGui.QCompleter([], self.ui.edNombreCliente)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edNombreCliente.setCompleter(completer)
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreClienteSeleccionado)
        self.connect(self.ui.edNombreCliente, QtCore.SIGNAL("textEdited(QString)"), self.nombreClienteEditado)

        ## Filtros - Rango de fechas
        self.ui.laFiltroFechas.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        self.ui.fecha1.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha1.setDate(QtCore.QDate().currentDate().addDays(-0))
        self.connect(self.ui.fecha1, QtCore.SIGNAL('focusOut()'), self.fechaChanged)

        self.ui.fecha2.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha2.setDate(QtCore.QDate().currentDate())
        self.connect(self.ui.fecha2, QtCore.SIGNAL("focusOut()"), self.fechaChanged)

        self.ui.laFiltroVarios.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        ## Filtros - Document Type
        self.ui.laDocumentType.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")
        self.connect(self.ui.chDocumentType1, QtCore.SIGNAL("stateChanged(int)"), self.documentType1Changed)
        self.connect(self.ui.chDocumentType2, QtCore.SIGNAL("stateChanged(int)"), self.documentType2Changed)

        ## Filtros - Incluir canceladas
        self.connect(self.ui.chIncluirCanceladas, QtCore.SIGNAL("stateChanged(int)"), self.incluirCanceladasChanged)

        ## Filtros - Incluir servicios
        if app.distribution == app.BASICO:
            # self.ui.frame.hide()
            self.connect(self.ui.chIncluirServicios, QtCore.SIGNAL("stateChanged(int)"), self.incluirServiciosChanged)

        ## Filtros - SumasDiarias
        self.connect(self.ui.chSumasDiarias, QtCore.SIGNAL("stateChanged(int)"), self.sumasDiariasChanged)

        ## TABLA DE CONSULTA
        # self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF")
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        # self.ui.tablaConsulta.setColumnCount(6)
        # self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Folio", u"Documento", u"Fecha", u"Status", u"Monto", u"Cliente"])
        # self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)

        self.ui.tablaConsulta.sortItems(-1)

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("resized(QEvent)"), self.resizedTablaConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"&Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon1 = QtGui.QIcon()
        icon1.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon1, u"&Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Eliminar
        icon2 = QtGui.QIcon()
        icon2.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon2, u"&Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        # if not self.owner.app.reach&3:
            # self.ui.toEliminar.setVisible(False)
            # self.aEliminar.setVisible(False)
            # self.aEliminar.setToolTip(u"El borrado de ventas no está permitido")

        ## Detalles
        self.aDetalles = QtGui.QAction(u"Detalles", self)
        self.aDetalles.setShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_D))
        self.connect(self.aDetalles, QtCore.SIGNAL("triggered()"), self.detallesTriggered)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.owner.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.ui.toImprimir.setToolTip(u"Se imprime sólo los renglones mostrados en la lista")

        ## Menu
        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.connect(session.eventRouter, QtCore.SIGNAL("clientesChanged()"), self.actualizaConsulta)
        self.connect(session.eventRouter, QtCore.SIGNAL("ventasChanged()"), self.listChanged)

        ## Inicialización de datos
        self.cliente = None

        self.upToDate = False
        # self.actualizaConsulta()

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)


    #~ @property
    #~ def app(self):
        #~ return self.__owner.app


    def actualizaBotones(self):
        if not self.owner.captura.isVisible():
            self.aModificar.setChecked(False)
        self.aImprimir.setChecked(False)

        mensajesFiltros = u""
        mensajesModifica = u""
        mensajesImprime = u""

        if model.salesCount == 0:
            mensajesFiltros += u"No hay ventas registradas\n"
            mensajesModifica += u"No hay ventas registradas\n"
            mensajesImprime += u"No hay ventas para imprimir\n"

        elif self.ui.tablaConsulta.rowCount() == 0:
            mensajesModifica += u"No hay ventas desplegadas\n"
            mensajesImprime += u"No hay compras desplegadas\n"

        elif self.ui.tablaConsulta.rowCount() > 0:
            if self.ui.tablaConsulta.currentRow() == -1:
                mensajesModifica += u"Selecciona la Compra que quieres Modificar"

        if mensajesFiltros:
            self.ui.frFiltros.setEnabled(False)
            self.ui.frFiltros.setToolTip(mensajesFiltros.rstrip("\n"))
        else:
            self.ui.frFiltros.setEnabled(True)
            self.ui.frFiltros.setToolTip(u"")

        if mensajesModifica:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(mensajesModifica.rstrip("\n"))
        else:
            self.aModificar.setEnabled(True)
            self.aModificar.setToolTip(u"Presiona para modificar los datos de la Venta seleccionada")

        if mensajesImprime:
            self.aImprimir.setEnabled(False)
            self.aImprimir.setToolTip(mensajesImprime.rstrip("\n"))
        else:
            self.aImprimir.setEnabled(True)
            self.aImprimir.setToolTip(u"Presiona para Imprimir las ventas mostradas")


    def actualizaConsulta(self, date=None):
        print "ventas.igu.Administrador.actualizaConsulta()", date, self.isVisible(), self.upToDate

        if self.isVisible() and not self.upToDate:

            session.mainForm.setCursor(QtCore.Qt.WaitCursor)
            self.setCursor(QtCore.Qt.WaitCursor)

            filtros = {}
            filtros['inicio'] = self.ui.fecha1.date().toPyDate()
            filtros['termino'] = self.ui.fecha2.date().toPyDate() + datetime.timedelta(days=1)

            if self.cliente:
                filtros['cliente_id'] = self.cliente['id']

            if self.ui.chDocumentType1.isChecked():
                if not self.ui.chDocumentType2.isChecked():
                    filtros['documentType'] = model.getAttribute(grupo='tipoDocumento', nombre=u'factura')['id']
            else:
                if self.ui.chDocumentType2.isChecked():
                    filtros['documentType'] = model.getAttribute(grupo='tipoDocumento', nombre=u'remisión')['id']

            if self.ui.chIncluirCanceladas.isChecked():
                filtros['procesos.status IN'] = ('abierto', 'cancelado')
            else:
                filtros['procesos.status'] = u'abierto'

            self.ui.tablaConsulta.setRowCount(0)

            if self.ui.chSumasDiarias.isChecked():
                self.ui.tablaConsulta.setColumnCount(5)
                self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Fecha", "Monto s/IVA", "Monto c/IVA", u"", u""])

                self.ui.tablaConsulta.showColumn(0)

                filtros['sumasDiarias'] = True

                sales = model.sales(**filtros)

                semana = Decimal("0.00")
                total = Decimal("0.00")

                for index, dato in enumerate(sales):

                    self.ui.tablaConsulta.insertRow(0)

                    # item = QtGui.QTableWidgetItem(dato['fecha'].toString("dd MMM yyyy"))
                    item = QtGui.QTableWidgetItem(dato['fecha'].strftime("%d %b %Y"))
                    # item.setFont(font)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setData(QtCore.Qt.UserRole, QtCore.QVariant(-1))
                    self.ui.tablaConsulta.setItem(0, 0, item)

                    item1 = QtGui.QTableWidgetItem(str(dato['total']))
                    item1.setFlags(item1.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(0, 1, item1)

                    item2 = QtGui.QTableWidgetItem(str(dato['total']))
                    item2.setFlags(item2.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(0, 2, item2)

                    semana += dato['total']
                    total += dato['total']

                    # if dato['fecha'].dayOfWeek() == 6:
                    if dato['fecha'].weekday() == 6:
                        item3 = QtGui.QTableWidgetItem(str(semana))
                        item4 = QtGui.QTableWidgetItem(str(total))
                    else:
                        item3 = QtGui.QTableWidgetItem("")
                        item4 = QtGui.QTableWidgetItem("")

                    item3.setFlags(item3.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(0, 3, item3)

                    item4.setFlags(item4.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(0, 4, item4)

                    if dato['fecha'].weekday() == 6:
                        semana = Decimal("0.00")
                        item.setBackgroundColor(QtGui.QColor(204,204,255))
                        item1.setBackgroundColor(QtGui.QColor(204,204,255))
                        item2.setBackgroundColor(QtGui.QColor(204,204,255))
                        item3.setBackgroundColor(QtGui.QColor(204,204,255))
                        item4.setBackgroundColor(QtGui.QColor(204,204,255))

            else:
                labels = [u"Documento", u"Fecha", u"Cliente", u"Monto", u"Saldo", u"Status", u""]
                self.ui.tablaConsulta.setColumnCount(len(labels))
                self.ui.tablaConsulta.setHorizontalHeaderLabels(labels)
                self.ui.tablaConsulta.horizontalHeader().setResizeMode(6, QtGui.QHeaderView.Stretch)

                ventas = model.sales(**filtros)
                #~ print ventas

                self.ui.tablaConsulta.setSortingEnabled(False)

                self.ui.tablaConsulta.setRowCount(0)
                color = QtGui.QColor(1,1,1)
                saldo = Decimal('0.00')
                documentosProcesados = []

                for indexProceso, proceso in enumerate(ventas):

                    if indexProceso%2:
                        color.setNamedColor('#E0E0FF')
                    else:
                        color.setNamedColor('#FFFFE0')

                    subProcesos = []

                    for indexOperacion, operacion_id in enumerate(proceso['operaciones_id']):

                        filters = {}
                        filters['operacion_id'] = operacion_id
                        documentos = model.getDocumentos(**filters)

                        if documentos:
                            documento = documentos[0]

                            if documento['documento_id'] == -1:
                                subProcesos.append([proceso['proceso_id'], proceso['operaciones_tipo'][indexOperacion], u'', proceso['operaciones_fecha'][indexOperacion], u'', proceso['operaciones_monto'][indexOperacion], proceso['operaciones_status'][indexOperacion]])
                            else:
                                if not documento['documento_id'] in documentosProcesados:
                                    rol = model.getRol(id=documento['rol_id'])
                                    tipo = model.getAttribute(id=documento['tipo_id'])
                                    subProcesos.append([proceso['proceso_id'], tipo['nombre'], documento['folio'], documento['fecha'], "%s %s" % (rol['nombre'], rol['nombre2']), documento['total'], documento['status']])
                                    documentosProcesados.append(documento['documento_id'])
                        else:
                            if proceso['operaciones_tipo'][indexOperacion] != u'Cobro':
                                print (55555), 'ERROR ------------------------'
                                print "ventas.igu.Administrador.actualizaConsulta()"
                                print "proceso:", indexProceso, proceso
                                # print "operacion:", indexOperacion, operacion
                                print "documentos:", documentos

                    for indexSubproceso in range(len(subProcesos)-1):
                        for indexSubproceso2 in range(len(subProcesos)-1-indexSubproceso):
                            if subProcesos[indexSubproceso2][3] > subProcesos[indexSubproceso2+1][3]:
                                temp = subProcesos[indexSubproceso2]
                                subProcesos[indexSubproceso2] = subProcesos[indexSubproceso2+1]
                                subProcesos[indexSubproceso2+1] = temp

                    for indexSubproceso, subProceso in enumerate(subProcesos):
                        self.ui.tablaConsulta.insertRow(0)

                        if subProceso[1] in [u'factura', u'remisión']:
                            saldo -= abs(subProceso[5])
                        elif not subProceso[1] in [u'pedido']:
                            saldo += abs(subProceso[5])

                        # item = QtGui.QTableWidgetItem("")
                        # item.setData(QtCore.Qt.UserRole, QtCore.QVariant(subProceso[0]))
                        # self.ui.tablaConsulta.setItem(0, 0, item)

                        item = QtGui.QTableWidgetItem("%s %s" % (subProceso[1].capitalize(), subProceso[2]))
                        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        # if not index2:
                            # item.setTextAlignment(QtCore.Qt.AlignLeft)
                        # else:
                            # item.setTextAlignment(QtCore.Qt.AlignRight)
                        # item.setBackgroundColor(color)
                        item.setData(1000, QtCore.QVariant(subProceso[0]))
                        self.ui.tablaConsulta.setItem(0, 0, item)

                        # item = QtGui.QTableWidgetItem("%s" % subProceso[2])
                        # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        # item.setTextAlignment(QtCore.Qt.AlignCenter)
                        # item.setBackgroundColor(color)
                        # self.ui.tablaConsulta.setItem(0, 2, item)

                        item = QtGui.QTableWidgetItem(subProceso[3].strftime("%d %b %Y"))
                        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        item.setTextAlignment(QtCore.Qt.AlignCenter)
                        # item.setBackgroundColor(color)
                        self.ui.tablaConsulta.setItem(0, 1, item)

                        item = QtGui.QTableWidgetItem(subProceso[4])
                        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        # item.setBackgroundColor(color)
                        self.ui.tablaConsulta.setItem(0, 2, item)

                        item = QtGui.QTableWidgetItem("%.2f" % subProceso[5])
                        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        item.setTextAlignment(QtCore.Qt.AlignCenter)
                        # item.setBackgroundColor(color)
                        self.ui.tablaConsulta.setItem(0, 3, item)

                        item = QtGui.QTableWidgetItem("%.2f" % saldo)
                        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        item.setTextAlignment(QtCore.Qt.AlignCenter)
                        # item.setBackgroundColor(color)
                        self.ui.tablaConsulta.setItem(0, 4, item)

                        item = QtGui.QTableWidgetItem(subProceso[6])
                        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                        item.setTextAlignment(QtCore.Qt.AlignCenter)
                        # item.setBackgroundColor(color)
                        self.ui.tablaConsulta.setItem(0, 5, item)

                        item = QtGui.QTableWidgetItem(u"")
                        self.ui.tablaConsulta.setItem(0, 6, item)

                # self.ui.tablaConsulta.setSortingEnabled(True)

                self.actualizaBotones()

                self.ui.tablaConsulta.resizeColumnToContents(2)
                self.ui.tablaConsulta.resizeColumnToContents(0)
                # self.ui.tablaConsulta.resizeColumnToContents(3)
                # self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
                # self.ui.tablaConsulta.resizeColumnToContents(7)

            self.upToDate = True

            session.mainForm.setCursor(QtCore.Qt.ArrowCursor)
            self.setCursor(QtCore.Qt.ArrowCursor)


    def agrega(self):
        self.owner.captura.agrega()


    def clienteSeleccionado(self, cliente):

        self.ui.edNombreCliente.setText("%s %s" % (cliente.entidad.nombre, cliente.entidad.nombre2))
        self.ui.edRFCCliente.setText(cliente.entidad.rfc)

        self.cliente = cliente

        self.upToDate = False
        self.actualizaConsulta()


    def detallesTriggered(self):
        if self.ui.tablaConsulta.selectedItems():
            self.mostrarDetalles()
        else:
            app.beep()


    def documentType1Changed(self, state):
        print "ventas.igu.Administrador.documentType1Changed(%s)", state
        if not self.ui.chDocumentType1.isChecked():
            if not self.ui.chDocumentType2.isChecked():
                self.ui.chDocumentType1.setChecked(True)
                return
        self.upToDate = False
        self.actualizaConsulta()


    def documentType2Changed(self, state):
        print "ventas.igu.Administrador.documentType2Changed()"
        if not self.ui.chDocumentType2.isChecked():
            if not self.ui.chDocumentType1.isChecked():
                self.ui.chDocumentType2.setChecked(True)
                return
        self.upToDate = False
        self.actualizaConsulta()


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar venta", u"Selecciona la Venta que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            dato = model.getDocument(id=id)
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar venta", u"¿Realmente quieres ELIMINAR la Venta %s %s?" % (dato.folio, dato.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                model.elimina(id=id)
                self.upToDate = False
                self.actualizaConsulta()
                self.emit(QtCore.SIGNAL("changed()"))
            self.actualizaBotones()


    def fechaChanged(self):         # print "ventas.igu.Administrador.fechaChanged()"
        if self.ui.fecha1.date() > self.ui.fecha2.date():
            self.ui.fecha1.setDate(self.ui.fecha2.date())
        self.upToDate = False
        self.actualizaConsulta()


    # def getDate1(self):

    def incluirCanceladasChanged(self, state):
        self.upToDate = False
        self.actualizaConsulta()


    def incluirServiciosChanged(self, state):
        self.upToDate = False
        self.actualizaConsulta()


    def listChanged(self):
        self.upToDate = False
        self.actualizaConsulta()


    def modifica(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar venta", u"Seleccione la Venta que quiere MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(QtCore.Qt.UserRole).toInt()[0]
            self.owner.captura.modifica(id)


    def mostrarDetalles(self, item):
        # id = self.ui.tablaConsulta.item(item.row(), 0).data(1000).toInt()[0]
        self.owner.detalles.actualiza()
        self.owner.detalles.show()
        self.owner.ui.innerSplitter.setSizes([1, 1])

    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    def nombreClienteEditado(self, texto):
        filtros = {}
        filtros['nombre'] = unicode(texto)

        clientes = model.getRoles(**filtros)

        ids = [x['id'] for x in clientes]
        nombres = ["%s %s" % (x.entidad.nombre, x.entidad.nombre2) for x in clientes]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(nombres)

        self.cliente = None


    def nombreClienteSeleccionado(self, completerModelIndex):
        cliente = model.getRoles(id=self.sender().data[completerModelIndex.row()])
        self.clienteSeleccionado(cliente)


    @property
    def owner(self):
        return self.__owner


    def resizedTablaConsulta(self, event):
        headerWidth = self.ui.tablaConsulta.width()-self.ui.tablaConsulta.verticalHeader().width()-self.ui.tablaConsulta.verticalScrollBar().width()
        self.ui.tablaConsulta.horizontalHeader().setMinimumWidth(headerWidth)

        porcentajes = [10, 10, 15, 12, 12]
        overflow = 0

        for index in range(self.ui.tablaConsulta.horizontalHeader().count()-1):

            self.ui.tablaConsulta.resizeColumnToContents(index)

            porContenido = self.ui.tablaConsulta.columnWidth(index)
            calculado = headerWidth * porcentajes[index] / 100

            if porContenido < calculado:
                if overflow:
                    offset = calculado - porContenido
                    if offset > overflow:
                        calculado = calculado - overflow
                        overflow = 0
                    else:
                        overflow -= offset
                        calculado = porContenido
                self.ui.tablaConsulta.setColumnWidth(index, calculado)
            else:
                overflow += porContenido - calculado

    def selectionChanged(self):
        if not self.ui.chSumasDiarias.isChecked():
            if self.ui.tablaConsulta.currentRow() != -1:
                # id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                self.owner.detalles.actualiza()
                # if self.owner.detalles.isVisible():
                    # self.owner.detalles.mostrar(id)
                if self.owner.captura.isVisible():
                    if self.owner.captura.mode == 'modificar':
                        if self.owner.captura.id != id:
                            if self.owner.captura.estaModificado():
                                result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Compra", u"La captura de Venta tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.tipo, self.owner.captura.old.folio, self.owner.captura.old.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)

                                if result == QtGui.QMessageBox.Yes:
                                    self.owner.captura.guarda()
                            self.owner.captura.modifica(id)
            self.actualizaBotones()


    def setCurrentId(self, id):
        self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))


    def showed(self):               # print "ventas.igu.Administracion.showed()"
        self.actualizaConsulta()
        session.mainForm.informacion = u""


    def sumasDiariasChanged(self, state):
        self.upToDate = False
        self.actualizaConsulta()



class Captura(cdFrame.CDFrame):

    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__mode = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        self.connect(self.ui.frame, QtCore.SIGNAL('returnPressed()'), self.returnPressed)

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(10)

        ## Folio
        self.ui.numberED.setFont(font)
        self.ui.numberED.setAlignment(QtCore.Qt.AlignHCenter)
        self.ui.numberED.setStyleSheet("color:#2020FF;")
        # if self.owner.app.reach&3:
            # self.ui.numberED.setReadOnly(False)

        self.ui.numberED.status = st.Ok
        self.connect(self.ui.numberED, QtCore.SIGNAL('editingFinished()'), self.validateFolio)

        ## Fecha
        self.ui.fecha.setDisplayFormat('dd MMM yyyy')
        self.ui.fecha.setMaximumDate(QtCore.QDate(QtCore.QDate().currentDate().year(), 12, QtCore.QDate().currentDate().day()))

        ## Orden de compra
        self.ui.documentReferenceFR.setVisible(False)

        ## Bar Code
        completer = QtGui.QCompleter([], self.ui.barCodeED)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        modelx = Model(completer)
        completer.setModel(modelx)
        self.ui.barCodeED.setCompleter(completer)
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.barCodeSelected)
        self.connect(self.ui.barCodeED, QtCore.SIGNAL('returnPressed()'), self.barCodeCaptured)
        self.connect(self.ui.barCodeED, QtCore.SIGNAL('textEdited(QString)'), self.barCodeEdited)

        self.updateUseBarCode()
        #~ if not model.getAttribute(grupo='ventas', nombre='useBarCode')['valor']:
            #~ self.ui.barCodeFR.hide()

        ## Código de producto
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        modelx = Model(completer)
        completer.setModel(modelx)
        self.ui.edCodigoProducto.setCompleter(completer)
        # self.ui.edCodigoProducto.setInputMask(">")
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('textEdited(QString)'), self.codigoProductoEditado)

        ## Código de producto 2
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto2)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edCodigoProducto2.setCompleter(completer)
        # self.ui.edCodigoProducto.setInputMask(">")
        # self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        # self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto2, QtCore.SIGNAL('textEdited(QString)'), self.codigoProducto2Editado)

        self.ui.frCodigo2.hide()

        ## Nombre de producto
        completer = QtGui.QCompleter([], self.ui.edNombreProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)

        modelx = Model(completer)
        completer.setModel(modelx)

        self.ui.edNombreProducto.setCompleter(completer)

        # completer.setCompletionMode(QtGui.QCompleter.PopupCompletion)

        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('returnPressed()'), self.nombreProductoCapturado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL("textEdited(QString)"), self.nombreProductoEditado)

        ## Linea de producto
        self.cargaLineas()
        #~ self.connect(self.ui.frLinea, QtCore.SIGNAL(), self.lineChanged)

        self.updateUseLine()

        #~ completer = QtGui.QCompleter([], self.ui.cbLinea)
        #~ completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        #~ completer.setCompletionMode(QtGui.QCompleter.PopupCompletion)
        #~ self.ui.edClasificacion.setCompleter(completer)
        # self.connect(self.ui.edClasificacion, QtCore.SIGNAL('returnPressed()'), self.clasificacionCapturada)
        # self.connect(self.ui.edClasificacion, QtCore.SIGNAL("textEdited(QString)"), self.clasificacionEditada)
        # self.cargaClasificaciones()

        # self.ui.cbClasificacion.hide()

        ## Nuevo producto
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.newProductBU.setIcon(icon)
        self.connect(self.ui.newProductBU, QtCore.SIGNAL('clicked()'), self.addProduct)

        ## Cliente
        self.ui.selectorCliente = selectorCliente.Forma(self, u'clientes')
        self.ui.selectorCliente.setContent(self.ui.selectorCliente.content() ^ self.ui.selectorCliente.TELEFONO)
        self.ui.headerLY.insertWidget(0, self.ui.selectorCliente)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL('nombreEdited()'), self.customerNameEdited)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clienteEdited()"), self.clienteEditado)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clienteSelected()"), self.clienteSeleccionado)
        #~ self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clientesChanged()"), self.clientesChanged)
        #~ self.connect(self.ui.selectorCliente, QtCore.SIGNAL('lugaresChanged()'), self.lugaresChanged)

        self.taxMode = st.TaxIncluded

        ## Tabla Partidas
        self.ui.tablaPartidas = TablaPartidas(self.ui.frame, owner=self, controlador=self.owner)
        self.ui.tablaPartidas.setFrameShape(QtGui.QFrame.NoFrame)
        self.ui.tablaPartidas.setFrameShadow(QtGui.QFrame.Raised)
        self.ui.tablaPartidas.setStyleSheet('background-color:#F8F8FF;')
        self.ui.tablaPartidas.setTabKeyNavigation(False)

        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.tablaPartidas.setColumnCount(len(labels))
        self.ui.tablaPartidas.setHorizontalHeaderLabels(labels)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(2)
        sizePolicy.setHeightForWidth(self.ui.tablaPartidas.sizePolicy().hasHeightForWidth())

        self.ui.tablaPartidas.setSizePolicy(sizePolicy)

        self.ui.layoutCaptura.insertWidget(3, self.ui.tablaPartidas)

        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged"), self.totalChanged)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('editingFinished()'), self.partidaCapturada)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('toggleRequested(QWidget)'), self.toggleRequested)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('dataChanged(QModelIndex, QModelIndex)'), self.updatePartidas)

        ## Tipo de documento  (Debe aparecer despues de Cliente y Tabla Partidas)
        self.connect(self.ui.documentTypeLA, QtCore.SIGNAL("clicked()"), self.tipoDocumentoCambiado)

        # self.ui.documentTypeCB.clear()
        tipos = model.tiposDocumento()
        self.ui.documentTypeLA.ids = []
        self.ui.documentTypeLA.names = []
        for tipo in tipos:
            self.ui.documentTypeLA.ids.append(tipo['id'])
            self.ui.documentTypeLA.names.append(tipo['nombre'].capitalize())

        self.ui.documentTypeLA.currentIndex = self.ui.documentTypeLA.ids.index(int(model.defaultDocumentType()['valor']))
        self.ui.documentTypeLA.setText(self.ui.documentTypeLA.names[self.ui.documentTypeLA.currentIndex])

        ## Preset Impuestos para Cálculo de total
        # self.impuestoGeneralFactor = (model.impuestoGeneral() + Decimal('100')) / Decimal('100')
        # self.setImpuestoIncluido(model.impuestoIncluido())

        ## Price rules
        self.togglePriceRule(0)

        ## Subtotal
        self.ui.edSubtotal.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edSubtotal.setRange(0, 99999)

        ## Descuento
        self.ui.edDescuento.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edDescuento.setRange(0, 99999)
        self.connect(self.ui.edDescuento, QtCore.SIGNAL('editingFinished()'), self.totalChanged)

        ## Impuesto
        self.ui.edImpuesto.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edImpuesto.setRange(0, 99999)

        ## Total
        font.setPointSize(9)
        self.ui.edTotal.setFont(font)
        self.ui.edTotal.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edTotal.setRange(0, 99999)
        self.connect(self.ui.edTotal, QtCore.SIGNAL('editingFinished()'), self.totalChanged)

        ## Pago
        # self.ui.laPago.hide()
        # self.ui.edPago.hide()
        # self.ui.laCambio.hide()
        # self.ui.edCambio.hide()
        # self.ui.laCondiciones.hide()
        # self.ui.cbCondiciones.hide()

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cash.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boPagar.setIcon(icon)

        self.connect(self.ui.boPagar, QtCore.SIGNAL('clicked()'), self.paga)

        self.pago = Pago(self)

        # self.ui.edPago.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        # self.ui.edPago.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        # self.ui.edPago.setStyleSheet('background-color:#F8F8FF')
        # self.ui.edPago.setRange(0, 99999)
        # self.ui.edPago.setPrefijoMensaje("el pago")
        # self.connect(self.ui.edPago, QtCore.SIGNAL("textEdited(QString)"), self.actualizaCambio)

        ## Cambio
        # self.ui.edCambio.setFont(font)
        # self.ui.edCambio.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        # self.ui.edCambio.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        # self.ui.edCambio.setReadOnly(True)

        ## Condiciones de Pago
        # self.ui.cbCondiciones.setFont(font)
        # self.ui.cbCondiciones.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        # self.connect(completer, QtCore.SIGNAL("activated(int)"), self.nombreProductoSeleccionado)
        # self.connect(self.ui.cbCondiciones, QtCore.SIGNAL('editTextChanged(QString)'), self.condicionesEdited)
        # self.connect(self.ui.cbCondiciones, QtCore.SIGNAL('lostFocus()'), self.condicionesLostFocus)
        # self.cargaCondiciones()

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuardar.setIcon(icon)
        self.ui.boGuardar.setIconSize(QtCore.QSize(32,32))
        self.ui.boGuardar.setEnabled(False)
        self.ui.boGuardar.setDefault(True)
        self.connect(self.ui.boGuardar, QtCore.SIGNAL('clicked()'), self.guarda)

        ## Limpiar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Restart.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boLimpiar.setIcon(icon)
        self.ui.boLimpiar.setIconSize(QtCore.QSize(32,32))
        self.connect(self.ui.boLimpiar, QtCore.SIGNAL('clicked()'), self.limpia)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,32))
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancela)

        self.connect(session.eventRouter, QtCore.SIGNAL('lineasChanged()'), self.cargaLineas)
        self.connect(session.eventRouter, QtCore.SIGNAL('clientesChanged()'), self.ui.selectorCliente.cargaNombres)
        self.connect(session.eventRouter, QtCore.SIGNAL('lugaresChanged()'), self.ui.selectorCliente.cargaLugares)
        self.connect(session.eventRouter, QtCore.SIGNAL('capturaPagoObligatoriaChanged'), self.actualizaStatus)
        self.connect(session.eventRouter, QtCore.SIGNAL('dateChangeAllowedChanged()'), self.updateDateChangeAllowed)
        self.connect(session.eventRouter, QtCore.SIGNAL('priceRulesChanged()'), self.priceRulesChanged)
        self.connect(session.eventRouter, QtCore.SIGNAL('useAuxiliaryCodeChanged()'), self.updateUseAuxiliaryCode)
        self.connect(session.eventRouter, QtCore.SIGNAL('useBarCodeChanged_venta()'), self.updateUseBarCode)
        self.connect(session.eventRouter, QtCore.SIGNAL('useLineChanged()'), self.updateUseLine)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)

        ## posSet
        self.setTabOrder(self.ui.documentTypeLA, self.ui.numberED)
        self.setTabOrder(self.ui.numberED, self.ui.fecha)
        self.setTabOrder(self.ui.fecha, self.ui.edOrden)
        self.setTabOrder(self.ui.edOrden, self.ui.selectorCliente.ui.edNombre)
        self.setTabOrder(self.ui.selectorCliente.ui.edNombre, self.ui.selectorCliente.ui.edNombre2)
        self.setTabOrder(self.ui.selectorCliente.ui.edNombre2, self.ui.selectorCliente.ui.edCalle)
        self.setTabOrder(self.ui.selectorCliente.ui.edCalle, self.ui.selectorCliente.ui.edAreaNominal)
        self.setTabOrder(self.ui.selectorCliente.ui.edAreaNominal, self.ui.selectorCliente.ui.cbLugar)
        self.setTabOrder(self.ui.selectorCliente.ui.cbLugar, self.ui.selectorCliente.ui.edRFC)
        self.setTabOrder(self.ui.selectorCliente.ui.edRFC, self.ui.selectorCliente.ui.edTelefono)
        self.setTabOrder(self.ui.selectorCliente.ui.edTelefono, self.ui.edCodigoProducto)
        self.setTabOrder(self.ui.edCodigoProducto, self.ui.edCodigoProducto2)
        self.setTabOrder(self.ui.edCodigoProducto2, self.ui.edNombreProducto)
        self.setTabOrder(self.ui.edNombreProducto, self.ui.cbLinea)
        self.setTabOrder(self.ui.cbLinea, self.ui.tablaPartidas)
        self.setTabOrder(self.ui.tablaPartidas, self.ui.boCancelar)
        self.setTabOrder(self.ui.boCancelar, self.ui.boLimpiar)
        self.setTabOrder(self.ui.boLimpiar, self.ui.boGuardar)
        self.setTabOrder(self.ui.boGuardar, self.ui.edSubtotal)
        # self.setTabOrder(self.ui.edPago, self.ui.edCambio)
        # self.setTabOrder(self.ui.edCambio, self.ui.boGuardar)
        # self.setTabOrder(self.ui.edPago, self.ui.edSubtotal)
        self.setTabOrder(self.ui.edSubtotal, self.ui.edDescuento)
        self.setTabOrder(self.ui.edDescuento, self.ui.edImpuesto)
        self.setTabOrder(self.ui.edImpuesto, self.ui.edTotal)
        # self.setTabOrder(self.ui.edTotal, self.ui.boGuardar)

        self.id = None

        self.ui.selectorCliente.ui.subFR.hide()

        # self.agrega()


    def addProduct(self):
        session.eventRouter.emit(QtCore.SIGNAL('addProduct(bool)'), True)



    def actualizaStatus(self):      # print "ventas.igu.Captura.actualizaStatus()"

        if self.mode == "modificar":
            if self.estaModificado():
                if self.esValida():
                    self.ui.boGuardar.setEnabled(True)
                    self.ui.boGuardar.setToolTip(u"")
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")
            else:
                self.ui.boGuardar.setEnabled(False)
                self.ui.boGuardar.setToolTip(u"No hay cambios")

        elif self.mode == 'agregar':
            if self.esValida():
                self.ui.boGuardar.setEnabled(True)
            else:
                self.ui.boGuardar.setEnabled(False)
            self.ui.boGuardar.setToolTip(self.mensajes)

        if self.ui.edTotal.value():
            self.ui.boPagar.setEnabled(True)
        else:
            self.ui.boPagar.setEnabled(False)


    def agrega(self):
        # self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "VENTA", None, QtGui.QApplication.UnicodeUTF8))

        self.__mode = 'agregar'
        self.clear()

        self.ui.numberED.setText(model.folio(self.ui.documentTypeLA.ids[self.ui.documentTypeLA.currentIndex]))

        self.ui.fecha.setDate(QtCore.QDate().currentDate())
        self.ui.laFecha.setText(QtCore.QDate().currentDate().toString('dd MMM yyyy'))
        self.ui.edCodigoProducto.setEnabled(True)
        self.ui.edCodigoProducto2.setEnabled(True)
        self.ui.edNombreProducto.setEnabled(True)
        self.ui.cbLinea.setEnabled(True)
        # self.ui.edClasificacion.setEnabled(True)
        # self.ui.cbClasificacion.setEnabled(True)

        self.pago.clear()

        self.actualizaStatus()
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\nPara activar la barra principal, presione F10"

        self.owner.setInnerStatus('hidden')

        self.ui.edNombreProducto.setFocus()

        self.show()


    def barCodeCaptured(self):
        if self.ui.barCodeED.completer().completionCount() == 1:
            if self.ui.barCodeED.completer().popup().currentIndex().row() == -1:
                modelx = self.ui.barCodeED.completer().completionModel()
                index = modelx.index(0, 0)
                self.barCodeSelected(index)


    def barCodeEdited(self, text):
        if len(text) < 2:
            self.ui.barCodeED.completer().model().clear()

        elif len(text) == 2:
            filtros = {}
            filtros['codigo LIKE'] = unicode(texto.toUpper())
            filtros['rol_id'] = app.holder['id']

            acepciones = model.aceptionsSelect(**filtros)

            self.ui.barCodeED.completer().model().clear()

            if not acepciones:
                self.ui.barCodeFR.setToolTip(u"El proveedor no tiene productos que lleven estas iniciales en el código de barras")
            else:
                self.ui.barCodeFR.setToolTip(u"")

                ## Set Model Data
                for row, acepcion in enumerate(acepciones):
                    self.ui.barCodeED.completer().model().setData(row, "%s %s" % (acepcion['codigo'], acepcion['nombre']))
                    self.ui.barCodeED.completer().model().setData(row, acepcion['id'], 1001)

                self.ui.barCodeED.completer().model().reset()

        if self.ui.barCodeED.text():
            self.ui.frameNombre.setEnabled(False)
            self.ui.frameNombre.setToolTip(u"Desactivado si se busca por codigo")
            self.ui.frLinea.setEnabled(False)
            self.ui.frLinea.setToolTip(u"Desactivado si se busca por codigo")
        else:
            self.ui.frameNombre.setEnabled(True)
            self.ui.frameNombre.setToolTip("")
            self.ui.frLinea.setEnabled(True)
            self.ui.frLinea.setToolTip(u"")


    def barCodeSelected(self, completerModelIndex):
        completerRow = completerModelIndex.row()

        modelx = self.ui.barCodeED.completer().completionModel()

        acepcion = model.getAception(id=modelx.data(modelx.index(completerRow, 0), 1001).toInt()[0])

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=-1, acepcion=acepcion, cantidad=Decimal('0.00'), precio=acepcion['costo'])

        self.ui.barCodeED.setText("")
        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.frameNombre.setEnabled(True)
        self.ui.frameNombre.setToolTip("")
        self.ui.frLinea.setEnabled(True)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.cellWidget(self.ui.tablaPartidas.rowCount()-1, CANTIDAD).selectAll()

        self.actualizaStatus()


    def cancela(self):
        self.clear()
        self.hide()
        self.emit(QtCore.SIGNAL("capturaClosed()"))


    def cargaCondiciones(self):     # print "ventas.igu.Captura.cargaCondiciones()"
        registros = model.condicionesPago()
        self.ui.cbCondiciones.clear()
        for registro in registros:
            self.ui.cbCondiciones.addItem(registro.nombre, QtCore.QVariant(registro['id']))


    def condicionesEdited(self):
        if self.ui.cbCondiciones.findText(self.ui.cbCondiciones.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFFFF;")
        self.actualizaStatus()


    def condicionesLostFocus(self): # print "ventas.igu.Captura.condicionesLostFocus()"
        if self.ui.cbCondiciones.findText(self.ui.cbCondiciones.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFFFF;")
            self.ui.cbCondiciones.setCurrentIndex(self.ui.cbCondiciones.findText(self.ui.cbCondiciones.currentText(), QtCore.Qt.MatchStartsWith))
        self.actualizaStatus()


    def cargaLineas(self):
        self.ui.cbLinea.clear()

        lineas = model.getLineas()
        for linea in lineas:
            self.ui.cbLinea.addItem(linea['nombre'], QtCore.QVariant(linea['id']))

        # ids = [x.id for x in lineas]
        # nombres = ["%s" % x.nombre for x in lineas]
        # self.ui.edClasificacion.completer().data = ids
        # self.ui.edClasificacion.completer().model().setStringList(nombres)


    def clasificacionEditada(self, texto):
        pass
        # self.sender().setText(self.sender().text().toUpper())
        # filtros = {}
        # filtros['clasificacion'] = unicode(texto.toUpper())
        # filtros['rol_id'] = -1

        # acepciones = manejador.dameAcepciones(**filtros)

        # ids = [x.id for x in acepciones]
        # codigos = ["%s" % x.codigo for x in acepciones]

        # self.sender().completer().data = ids
        # self.sender().completer().model().setStringList(codigos)


    def clasificacionCapturada(self): # print "ventas.igu.Captura.clasificacionCapturada()"
        modelx = self.ui.edClasificacion.completer().completionModel()
        self.ui.edClasificacion.setText(self.ui.edClasificacion.completer().completionModel().data(self.ui.edClasificacion.completer().currentIndex()).toString())


    def clear(self):
        self.updateDateChangeAllowed()

        self.ui.documentTypeLA.currentIndex = self.ui.documentTypeLA.ids.index(int(model.defaultDocumentType()['valor']))
        self.ui.documentTypeLA.setText(self.ui.documentTypeLA.names[self.ui.documentTypeLA.currentIndex])


        self.ui.edCodigoProducto.clear()
        self.ui.edCodigoProducto2.clear()
        self.ui.edNombreProducto.clear()
        # self.ui.cbClasificacion.setCurrentIndex(-1)
        self.ui.cbLinea.clear()

        cliente = model.defaultCustomer()

        self.ui.selectorCliente.setData(cliente)

        self.ui.tablaPartidas.setRowCount(0)

        self.totalChanged(Decimal('0.00'))
        # self.ui.edSubtotal.setValue(Decimal('0.00'))
        # self.ui.edDescuento.setValue(Decimal('0.00'))
        # self.ui.edImpuesto.setValue(Decimal('0.00'))
        # self.ui.edTotal.setValue(Decimal('0.00'))

        self.ui.boPagar.setEnabled(False)
        self.ui.pagoFR.setEnabled(False)
        self.ui.recibidoLA.setText("")
        self.ui.cambioLA.setText("")

        # self.ui.edPago.clear()
        # self.ui.edCambio.clear()
        # self.ui.cbCondiciones.setCurrentIndex(-1)
        self.ui.laTotalConLetras.setText("")


    def clienteEditado(self):
        print "ventas.igu.Captura.clienteEditado()"
        self.actualizaStatus()


    def customerNameEdited(self):
        print "ventas.igu.Captura.customerNameEdited()"
        self.ui.selectorCliente.ui.subFR.show()
        self.actualizaStatus()


    def clienteSeleccionado(self):  # print "ventas.igu.Captura.clienteSeleccionado()"
        #! Checar manejo de Price rules
        self.actualizaStatus()
        self.ui.edNombreProducto.setFocus()


    def close(self):                # print "ventas.igu.Captura.close()"
        self.pago.destroy()


    def codigoProductoCapturado(self):
        if self.ui.edCodigoProducto.completer().completionCount() == 1:
            if self.ui.edCodigoProducto.completer().popup().currentIndex().row() == -1:
                modelx = self.ui.edCodigoProducto.completer().completionModel()
                index = modelx.index(0, 0)
                self.codigoProductoSeleccionado(index)


    def codigoProductoEditado(self, texto):
        if len(texto) < 2:
            self.ui.edCodigoProducto.completer().model().clear()

        elif len(texto) == 2:
            filtros = {}
            filtros['codigo LIKE'] = unicode(texto.toUpper())
            filtros['rol_id'] = app.holder['id']
            # self.sender().setText(self.sender().text().toUpper())
            # if self.ui.edClasificacion.text():
                # filtros['clasificacion'] = unicode(self.ui.edClasificacion.text())
            # acepciones = manejador.dameAcepciones(**filtros)
            acepciones = model.getAceptionsSelect(**filtros)

            self.ui.edCodigoProducto.completer().model().clear()

            if not acepciones:
                self.ui.frameCodigo.setToolTip(u"El proveedor no tiene productos que lleven estas iniciales en el código")
            else:
                self.ui.frameCodigo.setToolTip(u"")

                ## Set Model Data
                for row, acepcion in enumerate(acepciones):
                    self.ui.edCodigoProducto.completer().model().setData(row, "%s %s" % (acepcion['codigo'], acepcion['nombre']))
                    self.ui.edCodigoProducto.completer().model().setData(row, acepcion['id'], 1001)

                self.ui.edCodigoProducto.completer().model().reset()

                # ids = [x.id for x in acepciones]
                # codigos = ["%s" % x.codigo for x in acepciones]

                # self.sender().completer().data = ids
                # self.sender().completer().model().setStringList(codigos)

        if self.ui.edCodigoProducto.text():
            self.ui.frameNombre.setEnabled(False)
            self.ui.frameNombre.setToolTip(u"Desactivado si se busca por codigo")
            self.ui.frLinea.setEnabled(False)
            self.ui.frLinea.setToolTip(u"Desactivado si se busca por codigo")
        else:
            self.ui.frameNombre.setEnabled(True)
            self.ui.frameNombre.setToolTip("")
            self.ui.frLinea.setEnabled(True)
            self.ui.frLinea.setToolTip(u"")


            # ids = [x.id for x in acepciones]
            # codigos = ["%s" % x.codigo for x in acepciones]

            # self.sender().completer().data = ids
            # self.sender().completer().model().setStringList(codigos)


    def codigoProductoSeleccionado(self, completerModelIndex): # print "ventas.igu.Captura.codigoProductoSeleccionado()"

        completerRow = completerModelIndex.row()

        modelx = self.ui.edCodigoProducto.completer().completionModel()

        # acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        # Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        # if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            # acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        # else:
            # acepcionRol = acepcionOrigen

        acepcion = model.getAception(id=modelx.data(modelx.index(completerRow, 0), 1001).toInt()[0])

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=-1, acepcion=acepcion, cantidad=Decimal('0.00'), precio=acepcion['costo'])

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.frameNombre.setEnabled(True)
        self.ui.frameNombre.setToolTip("")
        self.ui.frLinea.setEnabled(True)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.cellWidget(self.ui.tablaPartidas.rowCount()-1, CANTIDAD).selectAll()
        #~ self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()

        # acepcion = manejador.dameAcepcion(id=self.sender().data[completerModelIndex.row()])


    def codigoProducto2Editado(self, texto):
        self.sender().setText(self.sender().text().toUpper())
        filtros = {}
        filtros['codigo'] = unicode(texto.toUpper())
        filtros['rol_id'] = app.holder['id']
        if self.ui.edClasificacion.text():
            filtros['clasificacion'] = unicode(self.ui.edClasificacion.text())

        acepciones = model.getAceptions(**filtros)

        ids = [x.id for x in acepciones]
        codigos = ["%s" % x.codigo for x in acepciones]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(codigos)


    def datos(self):
        datos = {}

        if self.mode == 'modificar':
            datos['id'] = self.id

        datos['tipoDocumento_id'] = self.ui.documentTypeLA.ids[self.ui.documentTypeLA.currentIndex]
        datos['folioDocumento'] = unicode(self.ui.numberED.text())

        datos['fecha'] = datetime.datetime.combine(self.ui.fecha.date().toPyDate(), datetime.datetime.today().time())

        if self.ui.selectorCliente.rol:
            datos['rol_id'] = self.ui.selectorCliente.rol['id']
        else:
            datos['rol_id'] = None
            datos['cliente'] = self.ui.selectorCliente.data()
            datos['tipo'] = u'cliente'

        # try:
            # datos['rol_id'] = self.ui.selectorCliente.cliente.id
        # except:
            # datos['rol_id'] = None

        datos['subtotal'] = self.ui.edSubtotal.value()
        datos['descuento'] = self.ui.edDescuento.value()
        # datos['descuentoPorcentaje'] = self.ui.edDescuentoPorcentaje.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        # datos['impuestoPorcentaje'] = self.ui.edImpuestoPorcentaje.value()
        datos['total'] = self.ui.edTotal.value()

        datos['pago'] = self.pago.datos

        datos['partidas'] = self.ui.tablaPartidas.data()

        return datos


    def estaModificado(self):
        if self.mode == 'modificar':
            data = self.datos()
            try:
                if self.old.rol_id==data['rol_id'] and self.old.subtotal==data['subtotal'] and self.old.descuento==data['descuento'] and self.old.impuesto==data['impuesto'] and self.old.total==data['total'] and not self.ui.tablaPartidas.estaModificado():
                    return False
                else:
                    return True
            except:
                return True
        else:
            return True


    def esValida(self):             # print "ventas.igu.Captura.esValida()"

        valida = True
        self.mensajes = ""

        if self.ui.numberED.status != st.Ok:     # Innecesario cuando el manejo de folios es correcto
            valida = False
            self.mensajes += u"El Folio ya existe\n"

        if not self.ui.fecha.lineEdit().text():
            valida = False
            self.mensajes += u"Falta la fecha\n"

        if not self.ui.selectorCliente.esValido():
            valida = False
            self.mensajes += self.ui.selectorCliente.mensajes
        else:
            if self.ui.selectorCliente.rol:
                if unicode(self.ui.documentTypeLA.text()).lower()==u'factura':
                    if self.ui.selectorCliente.rol['nombre'] == u'Público':
                        valida = False
                        self.mensajes += u"Debe capturar un cliente válido\n"

        partidasValidas, mensajes = self.ui.tablaPartidas.esValida()
        if not partidasValidas:
            valida = False
            self.mensajes += mensajes

        if not self.ui.edSubtotal.isValid:
            valida = False
            self.mensajes += u"Subtotal fuera de rango\n"

        if not self.ui.edDescuento.isValid:
            valida = False
            self.mensajes += u"Descuento fuera de rango\n"

        if not self.ui.edImpuesto.isValid:
            valida = False
            self.mensajes += u"Impuesto fuera de rango\n"

        if not self.ui.edTotal.isValid:
            valida = False
            self.mensajes += u"Total fuera de rango\n"

        if model.capturaDePagoObligatoria():

            if not self.pago.capturado:
                valida = False
                self.mensajes += u"Falta capturar el pago"

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def validateFolio(self):        # print "ventas.igu.Captura.validateFolio()"

        if model.documento(tipo=unicode(self.ui.documentTypeLA.text()), folio=unicode(self.ui.numberED.text())):
            validity = st.NotValid
        else:
            validity = 0

        if self.ui.numberED.status != validity:
            self.ui.numberED.status = validity

            self.actualizaStatus()



    def guarda(self):               # print "ventas.igu.Captura.guarda()"
        ## No se revisa validez de datos, para llegar aquí se tuvo que haber hecho
        ## Se solicita autorización para datos (cliente nuevo)
        self.setCursor(QtCore.Qt.WaitCursor)

        datos = self.datos()

        rolTemp = datos['rol_id']

        if self.mode == "agregar":
            documento = model.addSale(datos)
            if model.seImprimeComprobante:
                try:
                    self.owner.imprime(documento)
                except:
                    print "=== Error en impresion de comprobante"

            self.agrega()

        elif self.mode == "modificar":
            model.modifica(datos)

        session.eventRouter.emit(QtCore.SIGNAL("ventasChanged()"))
        session.eventRouter.emit(QtCore.SIGNAL("productosChanged()"))
        session.eventRouter.emit(QtCore.SIGNAL("movementsChanged()"))

        if not rolTemp:
            session.eventRouter.emit(QtCore.SIGNAL("clientesChanged()"))

        self.setCursor(QtCore.Qt.ArrowCursor)


    def limpia(self):
        self.clear()


    def modifica(self, id):
        # self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Venta", None, QtGui.QApplication.UnicodeUTF8))

        self.__mode = "modificar"
        self.clear()

        self.id = id

        data = model.documento(id=id)
        self.setData(data)

        self.ui.edCodigoProducto.setEnabled(False)
        self.ui.edCodigoProducto2.setEnabled(False)
        self.ui.edNombreProducto.setEnabled(False)
        self.ui.cbLinea.setEnabled(False)
        # self.ui.cbClasificacion.setEnabled(False)

        self.ui.tablaPartidas.setMode(self.mode)

        self.actualizaStatus()
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"

        self.owner.setInnerStatus('hidden')

        self.ui.selectorCliente.ui.edNombre.setFocus()

        self.show()


    @property
    def mode(self):
        return self.__mode


    def nombreProductoCapturado(self):
        if self.ui.edNombreProducto.completer().completionCount() == 1:
            if self.ui.edNombreProducto.completer().popup().currentIndex().row() == -1:
                modelx = self.ui.edNombreProducto.completer().completionModel()
                index = modelx.index(0, 0)
                self.nombreProductoSeleccionado(index)

            # self.ui.edNombreProducto.setText(self.ui.edNombreProducto.completer().currentCompletion())


    def nombreProductoEditado(self, texto):
        if len(texto) < 2:
            self.ui.edNombreProducto.completer().model().clear()
        # acepciones = []
        # self.sender().completer().data = []
        # self.sender().completer().model().setStringList([])

        elif len(texto) == 2:
            filtros = {}
            # if self.ui.edCodigoProducto.text():
                # filtros['codigo'] = unicode(self.ui.edCodigoProducto.text().toUpper())
            filtros['nombre like'] = unicode(texto)
            filtros['rol_id'] = app.holder['id']

            filtros['order'] = "nombre"

            # if self.ui.edClasificacion.text():
                # filtros['linea'] = unicode(self.ui.edClasificacion.text())

            #~ acepciones = manejador.dameAcepciones(**filtros)

            acepciones = model.getAceptionsSelect(**filtros)

            #~ print "filtros:\n    %s" % filtros
            #~ print "acepciones\n    %s" % acepciones

            self.ui.edNombreProducto.completer().model().clear()

            ## Set Model Data
            for row, acepcion in enumerate(acepciones):
                self.ui.edNombreProducto.completer().model().setData(row, "%s %s %s" % (acepcion['nombre'], acepcion['lineas'][0], acepcion['codigo']))
                self.ui.edNombreProducto.completer().model().setData(row, acepcion['id'], 1001)

            self.ui.edNombreProducto.completer().model().reset()

            # linea = manejador.atributoI(id=x.producto.lineas[0].valor)

            # ids = [x.id for x in acepciones]
            # nombres = ["%s - %s - %s" % (x.nombre, x.codigo, x.producto.lineas[0].nombre) for x in acepciones]

            # self.sender().completer().data = ids
            # self.sender().completer().model().setStringList(nombres)


    def nombreProductoSeleccionado(self, completerModelIndex=None): # print "ventas.igu.Captura.nombreProductoSeleccionado()"
        completerRow = completerModelIndex.row()

        modelx = self.ui.edNombreProducto.completer().completionModel()

        aception = model.getAception(id=modelx.data(modelx.index(completerRow, 0), 1001).toInt()[0])

        # ! checar el costo
        self.ui.tablaPartidas.setDatosRenglon(rowIndex=-1, acepcion=aception, cantidad=Decimal('0.00'), precio=aception['costo'])

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        # self.ui.tablaPartidas.cellWidget(self.ui.tablaPartidas.rowCount()-1, CANTIDAD).selectAll()
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()


    @property
    def owner(self):
        return self.__owner


    def paga(self):
        self.pago.setImporte(self.ui.edTotal.value())
        self.pago.setDate(self.ui.fecha.date().toPyDate())
        result = self.pago.exec_()
        if result == QtGui.QDialog.Accepted:
            if self.pago.registrable:
                self.guarda()
            elif self.pago.capturado():
                self.ui.pagoFR.show()
                self.ui.recibidoLA.setText("%s" % self.pago.ui.edMontoRecibido.value())
                self.ui.cambioLA.setText("%s" % self.pago.ui.edCambio.value())
            self.actualizaStatus()
        else:
            print "hju"


    def partidaCapturada(self):     # print "ventas.igu.Captura.partidaCapturada()"
        self.ui.edNombreProducto.setFocus()


    def partidasClicked(self, index): # print "ventas.igu.Captura.partidasClicked()"
        self.ui.tablaPartidas.edit(index)


    @property
    def currentPriceRule(self):
        ## Index
        return self.__currentPriceRule


    def priceRulesChanged(self):
        pass
        #! Do whatever needs to be done


    def returnPressed(self):        # print "ventas.igu.Captura.returnPressed()"
        if self.ui.boGuardar.isEnabled():
            self.guarda()


    def rfcEditado(self, text):
        filtros = {}
        if text:
            filtros['rfc'] = "LIKE %s%%" % text
        clientes = self.owner.bd.getMany("clientes", filtros)
        ids = [x['cliente_id'] for x in clientes]
        rfcs = [x['rfc'] for x in clientes]
        self.ui.edRFC.completer().data = ids
        self.ui.edRFC.completer().model().setStringList(rfcs)


    def setData(self, data):
        print "ventas.igu.Captura.setData()"

        direccion = data.rol.direcciones[0]

        #! Tipo de documento

        self.ui.numberED.setText(data.folio)

        self.ui.fecha.setDate(QtCore.QDate().currentDate())
        self.ui.laFecha.setText(QtCore.QDate().fromString(data.fecha.strftime("%d%m%Y"), "ddMMyyyy").toString('dd MMM yyyy'))

        print '=============1', self.ui.selectorCliente.ui.subFR.isVisible()
        self.ui.selectorCliente.setData(data.rol)
        print '=============2', self.ui.selectorCliente.ui.subFR.isVisible()

        self.ui.edSubtotal.setValue(data.subtotal)
        self.ui.edDescuento.setValue(data.descuento)
        self.ui.edImpuesto.setValue(data.impuesto)
        self.ui.edTotal.setValue(data.total)

        pagoZero = [x for x in data.operacion.procesos[0].operaciones if x.tipo==u'cobro']

        if pagoZero:
            self.pago.setData(pagoZero[0])

        # operacion = manejador.dameOperacion(documento_id=data.id)

        # self.pago.setDatos(operacion.referencia)

        # if operacion.referencia:
            # self.ui.edPago.setText("%s" % operacion.referencia)
        # else:
            # self.ui.edPago.setText("")

        self.ui.tablaPartidas.setData(data.partidas)


    # def setImpuestoIncluido(self, value):
        # if value:
            # self.__impuestoIncluido = True
        # else:
            # self.__impuestoIncluido = False

        # print '----', value, self.__impuestoIncluido

        # self.totalChanged(self.ui.tablaPartidas.getSubtotal())


    def showed(self):
        session.mainForm.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\nPara activar la barra principal, presione F10"
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\nPara activar la barra principal, presione F10"


    def tipoDocumentoCambiado(self):
        print "ventas.igu.Captura.tipoDocumentoCambiado()"

        if self.ui.documentTypeLA.currentIndex + 1 < len(self.ui.documentTypeLA.ids):
            self.ui.documentTypeLA.currentIndex += 1
        else:
            self.ui.documentTypeLA.currentIndex = 0

        print self.ui.documentTypeLA.currentIndex

        print self.ui.documentTypeLA.names

        #~ print self.ui.documentTypeLA.names[self.ui.documentTypeLA.currentIndex]

        print model.getAttribute(id=self.ui.documentTypeLA.ids[self.ui.documentTypeLA.currentIndex])['valor']

        self.ui.documentTypeLA.setText(self.ui.documentTypeLA.names[self.ui.documentTypeLA.currentIndex])

        if model.getAttribute(id=self.ui.documentTypeLA.ids[self.ui.documentTypeLA.currentIndex])['valor'] == u'fiscal':
            print 111
            self.ui.selectorCliente.setRfcObligatorio(True)
            self.taxMode = st.TaxOmitted
            # self.setImpuestoIncluido(False)

        else:
            print 222
            self.ui.selectorCliente.setRfcObligatorio(False)
            self.taxMode = st.TaxIncluded
            # self.setImpuestoIncluido(True)

        self.ui.tablaPartidas.redraw()

        self.ui.numberED.setText(model.folio(self.ui.documentTypeLA.ids[self.ui.documentTypeLA.currentIndex]))
        #~ self.ui.numberED.setText(model.folio(text))
        self.actualizaStatus()


    def togglePriceRule(self, index=None): # print "ventas.igu.Captura.togglePriceRule()"
        if index is None:
            if self.currentPriceRule+1 == len(model.activePriceRules()):
                self.__currentPriceRule = 0
            else:
                self.__currentPriceRule += 1
        else:
            self.__currentPriceRule = index

        self.ui.boRangoPrecio.setText(model.activePriceRules()[self.currentPriceRule]['valor'])
        # self.ui.tablaPartidas.cambiaPrecios(self.currentPriceRule)
        self.ui.tablaPartidas.redraw()


    def toggleRequested(self, arg):
        print "ventas.igu.Captura.toggleRequested()"
        f=g
        self.ui.tablaPartidas.currentItem().setData(QtCore.Qt.EditRole, QtCore.QVariant("%.2f" % Decimal("%.0f" % Decimal(str(item.data(QtCore.Qt.UserRole+1).toString())))))


    def totalChanged(self, subtotal=None):      # print "ventas.igu.Captura.totalChanged()"
        try:
            if subtotal is None:
                subtotal = self.ui.tablaPartidas.getSubtotal()

            descuento = self.ui.edDescuento.value()
            total = subtotal - descuento

            if self.taxMode == st.TaxIncluded:
                impuesto = Decimal("0.00")
            else:
                impuesto = (subtotal * session.generalTax) / Decimal('100')

            total += impuesto

            self.ui.edSubtotal.setValue(subtotal)
            self.ui.edDescuento.setValue(descuento)
            self.ui.edImpuesto.setValue(impuesto)
            self.ui.edTotal.setValue(total)

            if total:
                self.ui.laTotalConLetras.setText("Son %s" % utilities.moneyToText(self.ui.edTotal.value().quantize(session.moneyDecimals)))
                self.ui.boPagar.setEnabled(True)
            else:
                self.ui.boPagar.setEnabled(False)
        except:
            self.ui.edSubtotal.setText("-")
            self.ui.edDescuento.setText("-")
            self.ui.edImpuesto.setText("-")
            self.ui.edTotal.setText("-")

        self.actualizaStatus()


    def updateDateChangeAllowed(self):  # ventas.igu.Captura
        if model.dateChangeAllowed():
            self.ui.laFecha.hide()
            self.ui.fecha.show()
        else:
            self.ui.laFecha.show()
            self.ui.fecha.hide()
        self.actualizaStatus()


    def updatePartidas(self, index1, index2):
        print "ventas.igu.Administrador.updatePartidas()"
        #~ print index1
        #~ print self.ui.tablaPartidas.item(index1)


    def updateUseAuxiliaryCode(self):
        print "ventas.igu.Captura.updateUseAuxiliaryCode()"
        if not model.getAttribute(grupo='ventas', nombre='useAuxiliaryCode')['valor']:
            self.ui.frCodigo2.hide()
        else:
            self.ui.frCodigo2.show()


    def updateUseBarCode(self):
        # print "ventas.igu.Captura.updateUseBarCode()"
        if not model.getAttribute(grupo='ventas', nombre='useBarCode')['valor']:
            self.ui.barCodeFR.hide()
        else:
            self.ui.barCodeFR.show()


    def updateUseLine(self):
        if not model.getAttribute(grupo='ventas', nombre='useLine')['valor']:
            self.ui.frLinea.hide()
        else:
            self.ui.frLinea.show()




class Detalles(QtGui.QFrame):

    #~ @property
    #~ def eventRouter(self):
        #~ return self.__owner.eventRouter

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds): # print "ventas.igu.Detalles.__init__()"

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimir.setIcon(icon)

        self.connect(self.ui.toImprimir, QtCore.SIGNAL("clicked()"), self.imprimir)

        self.connect(self, QtCore.SIGNAL("doubleClicked()"), self.close)

        self.connect(session.eventRouter, QtCore.SIGNAL("clientesChanged()"), self.actualiza)
        self.connect(session.eventRouter, QtCore.SIGNAL("ventasChanged()"), self.actualiza)

        self.partidas = []
        self.status = 'normal'


    def actualiza(self):
        if self.owner.administrador.ui.tablaConsulta.selectedItems():
            id = self.owner.administrador.ui.tablaConsulta.item(self.owner.administrador.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if id:
                process = model.getFullProcess(proceso_id=id)

                self.setData(process)


    def imprimir(self):
        proceso = self.data
        documento = ([x for x in proceso.operaciones if x.tipo==u'salida'][0]).documentos[0]
        self.owner.imprime(documento)


    def setData(self, proceso):     # print "ventas.igu.Detalles.setData()"
        self.data = proceso

        print proceso

        operacionSalidaZero = [x for x in proceso['operations'] if x['operacion_tipo']==u'salida']
        if operacionSalidaZero:
            document = model.getDocuments(operacion_id=operacionSalidaZero[0]['operacion_id'])[0]

            tipo = model.getAttribute(id=document['tipo_id'])
            rol = model.getFullRol(id=document['rol_id'])
            partidas = model.getAll('partidasdocumento', documento_id=document['documento_id'])

            self.ui.laEtiquetaFolio.setText(tipo['nombre'].capitalize())
            self.ui.laFolio.setText(" %s" % document['folio'])
            self.ui.laFecha.setText(document['fecha'].strftime("%d %b %Y"))
            self.ui.laEntidad.setText("%s %s" % (rol['nombre'], rol['nombre2']))
            self.ui.laSubtotal.setText("%.2f" % document['subtotal'])
            self.ui.laDescuento.setText("%.2f" % document['descuento'])
            self.ui.laImpuesto.setText("%.2f" % document['impuesto'])
            self.ui.laTotal.setText("%.2f" % document['total'])

            font = QtGui.QFont()
            font.setBold(True)
            font.setPointSize(9)

            font2 = QtGui.QFont()
            font2.setBold(True)
            font2.setPointSize(8)

            for row, partida in enumerate(partidas):
                print partida
                if row+1 == self.ui.layoutPartidas.rowCount():
                    renglon = [QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel("")]
                    self.partidas.append(renglon)
                    for column in range(6):
                        self.ui.layoutPartidas.addWidget(self.partidas[row][column], row+1, column)
                        if column in [0, 2]:
                            self.partidas[row][column].setFont(font2)
                        else:
                            self.partidas[row][column].setFont(font)
                    self.partidas[row][3].setAlignment(QtCore.Qt.AlignCenter)
                    self.partidas[row][4].setAlignment(QtCore.Qt.AlignRight)
                    self.partidas[row][5].setAlignment(QtCore.Qt.AlignRight)

                for column in range(6):
                    self.partidas[row][column].show()

                #~ acepcion = model.getOne('acepciones', producto_id=partida['producto_id'], rol_id=session.app.holder['id'])
                aception = model.getAception(producto_id=partida['producto_id'], rol_id=app.holder['id'])

                #~ lineas = model.getAll('atributosproducto', producto_id=acepcion['producto_id'])

                self.partidas[row][0].setText("%s" % aception['codigo'])
                self.partidas[row][1].setText(" %s" % aception['nombre'])
                self.partidas[row][2].setText(" %s" % aception['lines'][0]['nombre'])
                self.partidas[row][3].setText("%s" % partida['cantidad'])
                if partida['precioneto']:
                    self.partidas[row][4].setText("%.2f" % partida['precioneto'])
                    self.partidas[row][5].setText("%.2f" % (partida['cantidad'] * partida['precioneto']))

            for row in range(len(partidas), len(self.partidas)):
                for column in range(6):
                    self.partidas[row][column].hide()



class Pago(QtGui.QDialog):

    @property
    def capturado(self):
        return self.__capturado

    @property
    def recibido(self):
        return self.ui.edMontoRecibido.value()

    @property
    def tipo(self):
        return self.__tipo

    def __init__(self, *args, **kwds):
        QtGui.QDialog.__init__(self, *args)

        self.ui = pagos_ui.Ui_Dialog()
        self.ui.setupUi(self)

        self.setWindowTitle(QtGui.QApplication.translate("DsDialog", "Taller Básico", None, QtGui.QApplication.UnicodeUTF8))
        self.setWindowIcon(QtGui.QIcon("imagenes/logo.png"))

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boToggle.setIcon(icon)
        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.triggered)

        self.tipos = [x['nombre'] for x in model.formasPago()]

        ## Importe
        self.ui.edImporte.setEnabled(False)

        ## Efectivo - recibido
        # self.ui.edMontoRecibido.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edMontoRecibido.setStyleSheet('background-color:#F8F8FF;')
        self.ui.edMontoRecibido.setRange(0, 99999)
        self.ui.edMontoRecibido.setPrefijoMensaje("el pago")
        self.connect(self.ui.edMontoRecibido, QtCore.SIGNAL("textEdited(QString)"), self.actualizaCambio)

        ## Efectivo - cambio
        self.ui.edCambio.setEnabled(False)

        ## Credito - plazo
        self.cargaCondiciones()
        self.connect(self.ui.cbPlazo, QtCore.SIGNAL('activated(int)'), self.plazoSeleccionado)

        ## Credito - pago inicial
        self.ui.frPagoInicial.hide()

        ## Aceptar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo2.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boAceptar.setIcon(icon)
        self.connect(self.ui.boAceptar, QtCore.SIGNAL('clicked()'), self.aceptar)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancelar)

        ## Registrar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/CheckMark.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boRegistrar.setIcon(icon)
        self.connect(self.ui.boRegistrar, QtCore.SIGNAL('clicked()'), self.registrar)

        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.triggered)

        self.__tipo = 0
        self.triggered(0)
        self.__capturado = False
        self.__registrable = False


    def aceptar(self):
        self.__capturado = True
        self.accept()


    def actualizaCambio(self):
        cambio = self.ui.edMontoRecibido.value() - self.ui.edImporte.value()
        self.ui.edCambio.setValue(cambio)
        self.actualizaStatus()


    def actualizaStatus(self):
        if self.esValido():
            self.ui.boAceptar.setEnabled(True)
            self.ui.boAceptar.setToolTip(u'OK')
            self.ui.boRegistrar.setEnabled(True)
            self.ui.boRegistrar.setToolTip(u'OK')
        else:
            self.ui.boAceptar.setEnabled(False)
            self.ui.boAceptar.setToolTip(self.mensajes)
            self.ui.boRegistrar.setEnabled(False)
            self.ui.boRegistrar.setToolTip(self.mensajes)


    def cancelar(self):
        self.reject()


    def cargaCondiciones(self):
        registros = model.condicionesPago()
        self.ui.cbPlazo.clear()
        for registro in registros:
            self.ui.cbPlazo.addItem(registro['valor'], QtCore.QVariant(registro['id']))


    def clear(self):
        self.__capturado = False
        self.__tipo = 0

        self.ui.daFecha.setDate(QtCore.QDate().currentDate())
        self.ui.edImporte.setText(u'')
        self.ui.edMontoRecibido.setText(u'')
        self.ui.edCambio.setText(u'')

        self.ui.cbPlazo.setCurrentIndex(-1)


    @property
    def datos(self):
        datos = {}
        datos['total'] = self.ui.edImporte.value()
        if self.tipos[self.tipo] == u'efectivo':
            datos['tipo'] = u'efectivo'
            datos['fecha'] = self.ui.daFecha.dateTime().toPyDateTime()
            datos['montoRecibido'] = self.ui.edMontoRecibido.value()
            datos['cambio'] = self.ui.edCambio.value()
        elif self.tipos['self.tipo'] == u'cheque':
            datos['tipo'] = u'cheque'
            datos['fecha'] = self.ui.daFecha.dateTime().toPyDateTime()
            datos['numero'] = self.ui.edNumero.text()
            datos['banco_id'] = self.ui.cbBanco.itemData(self.ui.cbBanco.currentIndex())
            # datos['emisor_id'] = self.
            datos['monto'] = self.ui.edMonto.value()

        return datos


    def esValido(self):
        valido = True
        self.mensajes = u''
        if self.tipos[self.tipo] == u'Efectivo':
            if self.ui.edCambio.value() < Decimal('0'):
                valido = False
                self.mensajes += u"El monto recibido no es válido\n"
        elif self.tipos[self.tipo] == u'Crédito':
            if not self.ui.cbPlazo.currentText():
                valido = False
                self.mensajes += u"Falta el plazo\n"

        elif self.tipos[self.tipo] == u'Banco':
            if not self.ui.cbBanco.currentText():
                valido = False
                self.mensajes += u"Falta el Banco\n"
        self.mensajes = self.mensajes.rstrip('\n')
        return valido


    @property
    def registrable(self):
        return self.__registrable


    def registrar(self):
        self.__capturado = True
        self.__registrable = True
        self.accept()


    def setData(self, datos):
        documento = datos.documentos[0]

        self.ui.edImporte.setValue(documento.total)

        if documento.tipo.nombre == u'efectivo':
            self.ui.edMontoRecibido.setValue(Decimal(documento.subtotal).quantize(session.moneyDecimals))
            self.ui.edCambio.setValue(Decimal(documento.descuento).quantize(session.moneyDecimals))
        elif documento.tipo.nombre == u'cheque':
            self.ui.cbBanco.setCurrentIndex(self.ui.cbBanco.findData(int(documento.referencia)))
            self.ui.edNumero.setText(documento.folio)
            self.ui.daFecha.setDate(documento.fecha)
            self.ui.edMonto.setValue(Decimal(documento.subtotal).quantize(session.moneyDecimals))
            self.ui.edEmisor.setText(u'%s %s' % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))


    def setDate(self, date):
        self.ui.daFecha.setDate(date)


    def setImporte(self, valor):
        self.ui.edImporte.setValue(valor)
        self.actualizaCambio()
        self.ui.edMontoRecibido.setFocus()


    def plazoSeleccionado(self):
        self.actualizaStatus()


    def triggered(self, index=None):
        if index is None:
            if self.tipo+1 == len(self.tipos):
                self.__tipo = 0
            else:
                self.__tipo += 1
        else:
            self.__tipo = index

        if self.tipos[self.tipo] == u'cheque':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.show()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.show()
            self.ui.frCredito.hide()

        elif self.tipos[self.tipo] == u'crédito':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.show()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.hide()
            self.ui.frCredito.show()

        elif self.tipos[self.tipo] == u'efectivo':
            self.ui.frEfectivo1.show()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.show()
            self.ui.frBanco.hide()
            self.ui.frCredito.hide()
        self.actualizaStatus()



class TablaPartidas(QtGui.QTableWidget):
    """ #!
        This thing must have it's own datasource, because it must know what the
        actual different prices and taxes are available, appart from the actual
        data captured in the cells. setData won't expect this background data,
        it expects the actual data displayed in the cells.
        MUST REFACTOR THIS TO MAKE THE TABLE CONTAIN ALL THE DATA NECESARY
    """

    def __init__(self, *args, **kwds):
        if kwds.has_key('mode'):
            self.__mode = kwds.pop('mode')
        else:
            self.__mode = None

        if kwds.has_key('controlador'):
            self.__controlador = kwds.pop('controlador')
        else:
            self.__controlador = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QTableWidget.__init__(self, *args)

        self.setWordWrap(False)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

        self.aEliminar = QtGui.QAction("Elimina", self)

        self.menu = QtGui.QMenu(self)
        self.menu.addAction(self.aEliminar)

        self.connect(self, QtCore.SIGNAL("itemChanged(QTableWidgetItem *)"), self.itemChanged)
        self.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.muestraMenu)

        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        self.setStatus(u'normal')

        self.actualPriceRule = 1        # 1=Rule1, 2=Rule2, ...

        self.rol = app.holder

        # delegate = Delegate(self)

        self.setItemDelegateForColumn(CANTIDAD, Delegate(self))


    def data(self):
        partidas = []
        for row in range(self.rowCount()):
            partida = {}
            partida['producto_id'] = self.item(row, 0).data(1000).toInt()[0]

            producto = model.getProduct(id=partida['producto_id'])

            try:
                partida['cantidad'] = Decimal('%s' % self.item(row, CANTIDAD).text()).quantize(Decimal('0.00'))
            except:
                partida['cantidad'] = Decimal("0.00")

            try:
                partida['costo'] = producto['costopromedio']
            except:
                partida['costo'] = Decimal("0.00")

            partida['impuesto'] = session.generalTax
            partida['descuento'] = Decimal("0.00")
            partida['precioneto'] = Decimal('%s' % self.item(row, PRECIO).data(1001).toString())
            partida['precio'] = Decimal('%s' % self.item(row, PRECIO).data(1000).toString())
            # partida['status'] = u"ejecutada"
            partidas.append(partida)

        return partidas


    def elimina(self):
        remove = True
        # if self.currentRow() < 0:
            # result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar partida", u"Selecciona la PARTIDA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
            # remove = False
        # else:
            # result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar partida", u"¿Realmente quieres ELIMINAR la PARTIDA?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            # if result == QtGui.QMessageBox.No:
                # remove = False

        if remove:
            self.removeRow(self.currentRow())
            self.emit(QtCore.SIGNAL("totalChanged"), self.getSubtotal())


    def estaModificado(self):       # print "ventas.igu.TablaPartidas.estaModificado()"
        if self.mode == 'modificar':
            modificado = False
            data = self.data()
            for index, item in enumerate(self.partidasOld):
                if not(item.cantidad==data[index]['cantidad'] and item.costo==data[index]['costo']):
                    modificado = True
            return modificado


    def esValida(self):             # print "ventas.igu.TablaPartidas.esValida()"
        valida = True
        self.mensajes = ""

        if self.rowCount():
            partidas = self.data()
            for index, partida in enumerate(partidas):
                # if self.cellWidget(index, CANTIDAD).data['1001'] == 'overflow':
                if self.item(index, CANTIDAD).data(1001).toString() == 'overflow':
                    valida = False
                    self.mensajes += u"La partida %s sobrepasa las existencias\n" % (index + 1)
                elif partida['cantidad'] == Decimal("0.00"):
                    valida = False
                    self.mensajes += u"partida %s sin cantidad\n" % (index + 1)
        else:
            valida = False
            self.mensajes += u"No hay partidas capturadas\n"

        return valida, self.mensajes


    def event(self, event):         # print "ventas.igu.TablaPartidas.event()"
        if event.type() == QtCore.QEvent.KeyPress:
            if event.key() == QtCore.Qt.Key_Return:
                if self.currentColumn() == 3:
                    self.setCurrentCell(self.currentRow(), 4)
                elif self.currentColumn() == 4:
                    self.emit(QtCore.SIGNAL('editingFinished()'))
        return QtGui.QTableWidget.event(self, event)


    def getSubtotal(self):          # print "ventas.igu.TablaPartidas.getSubtotal()"
        try:
            subtotal = Decimal("0.00")
            for row in range(self.rowCount()):
                importe = Decimal(str(self.item(row, 5).text())).quantize(session.moneyDecimals)            # quantize user entry
                subtotal += importe
        except:
            subtotal = 0
        return subtotal


    @property
    def mode(self):
        return self.__mode


    def itemChanged(self, item):    # print "ventas.igu.TablaPartidas.itemChanged()", item.row(), item.column(), item.text().toUtf8(), self.status
        if self.status == 'normal':
            if item.column() in [3]:
                self.quantityChanged()
                #~ self.redraw(item)

            if item.column() in [4]:
                self.priceChanged(item)


    def muestraMenu(self, pos):
        pos = self.mapToGlobal(pos)
        self.menu.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def priceChanged(self, item=None): # print "ventas.igu.TablaPartidas.priceChanged()"
        try:
            price = Decimal(str(item.text())).quantize(session.moneyDecimals)                                   # quantize user input
            if self.owner.taxMode == st.TaxIncluded:
                item.setData(1000, '%s' % (price / session.generalTaxFactor).quantize(session.moneyDecimals))   # quantize operation result
                item.setData(1001, '%s' % price)
            else:
                item.setData(1000, '%s' % price)
                item.setData(1001, '%s' % (price / session.generalTaxFactor).quantize(session.moneyDecimals))   # quantize operation result
            quantity = Decimal(str(self.item(item.row(), CANTIDAD).text())).quantize(Decimal('0.01'))           # quantize user input
            importe = (quantity * price).quantize(session.moneyDecimals)                                        # quantize operation result
            self.item(item.row(), IMPORTE).setText('%s' % importe)
        except:
            self.item(item.row(), IMPORTE).setText('***')
        self.emit(QtCore.SIGNAL("totalChanged"), self.getSubtotal())


    def priceEditingFinished(self):
        self.emit(QtCore.SIGNAL('editingFinished()'))


    def priceFocused(self):
        # print "priceFocused()", self.sender()
        self.sender().selectAll()


    def quantityChanged(self, text=None): # print "ventas.igu.TablaPartidas.quantityChanged()", self.currentRow(), self.cellWidget(self.currentRow(), CANTIDAD).text()

        rowIndex = self.currentRow()
        quantity = Decimal(str(self.item(rowIndex, CANTIDAD).text())).quantize(Decimal('0.00'))     # quantize user input

        self.redraw(self.item(rowIndex, 0))
        price = Decimal(str(self.item(rowIndex, PRECIO).text())).quantize(session.moneyDecimals)    # quantize user input
        importe = (quantity * price).quantize(session.moneyDecimals)     # quantize operation result

        self.item(rowIndex, IMPORTE).setText("%s" % importe)

        self.emit(QtCore.SIGNAL("totalChanged"), self.getSubtotal())


    def redraw(self, item=None):    # print "ventas.igu.TablaPartidas.redraw()"

        def redrawRow(item):
            ## Validar existencias
            if self.item(item.row(), CODIGO).data(1001).toString() != u'Servicio':
                stock = Decimal(str(self.item(item.row(), CANTIDAD).data(1000).toString()))
                quantity = Decimal(str(self.item(item.row(), CANTIDAD).text())).quantize(Decimal('0.00'))    # quantize user input
                if stock < quantity:
                    self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant("overflow"))
                    self.item(item.row(), CANTIDAD).setBackgroundColor(QtGui.QColor("#FF8080"))
                else:
                    self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant("0"))
                    self.item(item.row(), CANTIDAD).setBackgroundColor(QtGui.QColor("#FFFFFF"))

        if item is None:
            for rowIndex in range(self.rowCount()):
                redrawRow(self.item(rowIndex, 0))
        else:
            redrawRow(item)


    def setData(self, partidas):
        self.setRowCount(0)
        for partida in partidas:
            aception = model.getAception(producto_id=partida['producto_id'], rol_id=app.holder['id'])
            self.setDatosRenglon(-1, aception, partida['cantidad'], partida['precio'])


    def setDatosRenglon(self, rowIndex, acepcion, cantidad, precio): # print "ventas.igu.TablaPartidas.setDatosRenglon()"

        if rowIndex == -1:
            rowIndex = self.rowCount()
            self.insertRow(self.rowCount())
        else:
            if rowIndex > self.rowCount():
                self.insertRow(self.rowCount())

        informacion = u""
        oldStatus = self.status
        self.setStatus(u'settingDatosRenglon')

        ## Código - data=producto_id
        item = QtGui.QTableWidgetItem("%s" % acepcion['codigo'])        # may be int not unicode
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setData(1000, QtCore.QVariant(acepcion['producto_id']))
        item.setData(1001, QtCore.QVariant(model.getAttribute(id=acepcion['tipo_id'])['nombre']))
        self.setItem(rowIndex, CODIGO, item)

        ## Nombre
        item = QtGui.QTableWidgetItem(acepcion['nombre'])
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, NOMBRE, item)

        ## LINEA
        item = QtGui.QTableWidgetItem(acepcion['lines'][0]['nombre'])
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, LINEA, item)

        ## CANTIDAD
        # widget = cdNumberEdit.CDNumberEdit(self)
        # widget.setFrame(False)
        # widget.setStyleSheet('color:#303030; background-color:#FFFFFF;')
        # widget.setValue(cantidad)
        # widget.data = {}
        # widget.data['1000'] = acepcion['actual']
        # widget.data['1001'] = ''
        # widget.data['row'] = rowIndex
        # self.setCellWidget(rowIndex, CANTIDAD, widget)
        # self.connect(widget, QtCore.SIGNAL('textEdited(QString)'), self.quantityChanged)

        item = QtGui.QTableWidgetItem("%s" % cantidad)
        item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        item.setData(1000, QtCore.QVariant("%s" % acepcion['actual']))
        # self.connect(item, QtCore.SIGNAL('textEdited(QString)'), self.quantityChanged)
        self.setItem(rowIndex, CANTIDAD, item)

        ## PRECIO
        """ 1XX0 Precio Iva incluido
            1XX1 Precio Iva desglosado
            1X0X Precio 1
            1X1X precio 2
            Si se teclea un precio, se coloca en la posición correspondiente y se calculan los estados correspondientes.
        """
        #~ widget = cdNumberEdit.CDNumberEdit(self)
        #~ widget.setFrame(False)
        #~ widget.setStyleSheet('color:#303030; background-color:#FFFFFF;')
        #~ widget.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)

        item = QtGui.QTableWidgetItem()
        item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)

        # print acepcion['precios_id']

        # exec("acepcion['precios_id'] = list(%s)" % acepcion['precios_id'].replace('"(', '(').replace(')"', ')').replace('{', '[').replace('}', ']') )

        #~ widget.data = {}


        for rule in model.activePriceRules():
            # precioZero = [index for x in enumerate(acepcion['precios_id']) if x[1]==rule['id']]
            priceIndex = [index for index, price in enumerate(acepcion['prices']) if price['tipo_id']==rule['id']]

            if priceIndex:
                priceIndex = priceIndex[0]

                # precioX = precioZero[0]
                index = int(rule['referencia'][0])
                #~ widget.data['%s' % (1000+index*10)] = Decimal(str(acepcion['precios'][priceIndex]))/model.impuestoGeneralFactor()
                #~ widget.data['%s' % (1001+index*10)] = Decimal(str(acepcion['precios'][priceIndex]))

                #~ widget.data['row'] = rowIndex

                price = Decimal(acepcion['prices'][priceIndex]['valor']).quantize(session.moneyDecimals)
                item.setData(1000+index*10, '%s' % (price / session.generalTaxFactor).quantize(session.moneyDecimals))
                item.setData(1001+index*10, '%s' % price)

        #~ widget.setValue(widget.data['%s' % (1000+self.owner.taxMode+self.actualPriceRule*10)])

        item.setText("%s" % item.data(1000+self.owner.taxMode+self.actualPriceRule*10).toString())

        if self.owner.taxMode == st.TaxIncluded:   # Incluido
            item.setData(1000, '%s' % (Decimal(str(item.text())).quantize(session.moneyDecimals) / session.generalTaxFactor).quantize(session.moneyDecimals))
            item.setData(1001, '%s' % (Decimal(str(item.text())).quantize(session.moneyDecimals)))
        else:
            item.setData(1000, item.value())
            item.setData(1001, item.value() * session.generalTaxFactor())

        #~ self.connect(widget, QtCore.SIGNAL('textEdited(QString)'), self.priceChanged)
        #~ self.connect(widget, QtCore.SIGNAL('lostFocus()'), self.priceEditingFinished)
        #~ print "---", widget
        #~ self.setCellWidget(rowIndex, PRECIO, widget)

        self.setItem(rowIndex, PRECIO, item)



        '''
        item = QtGui.QTableWidgetItem("-1")
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)

        # if self.owner.impuestoIncluido:
            # item.setText("%s" % precio)
        # else:
            # item.setText("%s" % precio)

        exec("acepcion['precios'] = list(%s)" % acepcion['precios'].replace('"(', '(').replace(')"', ')').replace('{', '[').replace('}', ']') )

        for rule in model.activePriceRules():
            precioX = [x for x in acepcion['precios'] if x[1]==rule['id']]
            if precioX:
                precioX = precioX[0]
                index = int(rule['referencia'][0]) - 1
                item.setData(1000+index*10, QtCore.QVariant("%s" % Decimal(str(precioX[0]))))
                item.setData(1001+index*10, QtCore.QVariant("%s" % (Decimal(str(precioX[0]))/ self.owner.impuestoGeneralFactor)))

        self.setItem(rowIndex, PRECIO, item)
        '''

        ## IMPORTE
        importe = cantidad * precio

        item = QtGui.QTableWidgetItem("%.2f" % importe)
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, IMPORTE, item)


        self.redraw(self.item(rowIndex, 0))

        self.setStatus(u'normal')

        self.resizeColumnToContents(CODIGO)
        self.resizeColumnToContents(LINEA)
        self.resizeColumnToContents(CANTIDAD)

        informacion += u"Presiona F2 para modificar datos en la celda\n"

        session.mainForm.informacion = informacion.rstrip(u'\n')


    def setMode(self, mode):
        self.__mode = mode

        if mode == 'agregar':
            self.menu = QtGui.QMenu(self)
            self.menu.addAction(self.aElimina)
        elif mode == 'modificar':
            self.menu = QtGui.QMenu(self)


    def setStatus(self, valor):
        self.__status = valor


    @property
    def status(self):
        return self.__status



class Delegate(QtGui.QItemDelegate):

    def createEditor(self, parent, option, index):
        if index.column() == CANTIDAD:
            editor = cdNumberEdit.CDNumberEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            # self.connect(editor, QtCore.SIGNAL('textEdited(QString)'), self.quantityChanged)
            return editor

        elif index.column() == PRECIO:
            editor = PartidaNumberEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            return editor
        else:
            return QtGui.QItemDelegate.createEditor(self, parent, option, index)

    def commitAndCloseEditor(self):
        editor = self.sender()
        if isinstance(editor, (QtGui.QTextEdit, QtGui.QLineEdit)):
            self.emit(QtCore.SIGNAL('commitData(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('closeEditor(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('editingFinished(QWidget*)'), editor)



class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event):
        self.emit(QtCore.SIGNAL("handlePressed"))


class PartidaNumberEdit(cdNumberEdit.CDNumberEdit):

    def __init__(self, *args, **kwds):
        cdNumberEdit.CDNumberEdit.__init__(self, *args)

    def keyPressEvent(self, event):
        cdNumberEdit.CDNumberEdit.keyPressEvent(self, event)
        if event.key() == 80:   # P
            self.parent().parent().emit(QtCore.SIGNAL('toggleRequested(QWidget)'), self)



class Model(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        # self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.reset()
        # self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # if index.column() == CANTIDAD:
                # return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            # if index.column() in [PRECIO, IMPORTE]:
                # return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == 1001:
            return self.__data[index.row()][1]
        else:
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def setData(self, row, valor, role=QtCore.Qt.DisplayRole):
        """ No se usa la porquería de modelIndex """
        if row >= len(self.__data):
            self.__data.append([None, None])

        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[row][0] = QtCore.QVariant(valor)
        elif role == 1001:
            self.__data[row][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True







"""


Comportamiento para edPago y edCambio (incluye cambios a capturaPagoObligatoria)

Comportamiento para cbTipoDocumento
    No se debe facturar a Público general
    No se puede facturar a cliente nulo
    No se puede remisionar a cliente nulo

    Toggle impuestoIncluido
    Carga el folio correspondiente

21NOV09
Los precios son afectados por 2 factores hasta el momento :
    El impuesto
        Por el momento es sólo el IVA, y aplica por igual a todos los productos y
            servicios.
    El rango de precio (Price rule)
        Por el momento se contemplan 2, el General y el Preferente, el segundo se
            inicia deshabilitado

    Esto genera que la celda de precio de tabla de partidas maneje hasta 4 valores
        diferentes:
        Precio General con Impuesto
        Precio General sin Impuesto
        Precio Preferente con Impuesto
        Precio Preferente sin Impuesto

    Technicallity
        Las variantes de valores por cada celda se guardan en la variable data del
        item de esa celda.
        La variable data maneja roles y da opcion a varios definidos por el programador.
        Se manejaran los siguientes roles:
            QtCore.Qt.UserRole+1    Precio General con Impuesto
            QtCore.Qt.UserRole+2    Precio General sin Impuesto
            QtCore.Qt.UserRole+11   Precio Preferente con Impuesto
            QtCore.Qt.UserRole+12   Precio Preferente sin Impuesto
            Futuros nuevos rangos de Precio usarían lo siguiente
            QtCore.Qt.UserRole+21   Precio 3 con Impuesto
            QtCore.Qt.UserRole+22   Precio 3 sin Impuesto
            QtCore.Qt.UserRole+31   Precio 4 con Impuesto
            QtCore.Qt.UserRole+32   Precio 4 sin Impuesto

    Se puede hacer un cambio de Rangos de Precio, en los siguientes casos
    1- Cuando se cambia de cliente se puede recibir un evento de cambioRangoPrecio cuyo argumento
        es el rango seleccionado
    2- Cuando el usuario quiere consultar un valor de un rango diferente al actual


"""

"""
Situaciones

Se selecciona un cliente que no tiene registrado RFC
    - Si el tipo de documento es Remisión no hay error.
    - Si el tipo de documento es Factura es error y se tiene que capturar el RFC y registrsrlo.


"""
